@seriousme/opifex 1.11.3 → 2.1.0

package/mqttPacket/pingres.ts

@@ -1,42 +1,36 @@
 import { PacketType } from "./PacketType.ts";
 import { hasEmptyFlags, isEmptyBuf } from "./decoder.ts";
-import type { CodecOpts, ProtocolLevel, TPacketType } from "./types.ts";
+import type { CodecOpts } from "./types.ts";
+import type { ProtocolLevel } from "./protocolLevels.ts";
 
 /**
  * PingresPacket is  an empty packet that is sent by the server in response to a PingreqPacket.
  * It is used to indicate that the client is still connected to the server.
  */
 export type PingresPacket = {
-  type: TPacketType;
+  type: PacketType;
   protocolLevel: ProtocolLevel;
 };
 
 const PINGRES_PACKET = new Uint8Array([PacketType.pingres << 4, 0]);
 
-export const pingres: {
-  encode(packet: PingresPacket, _codecOpts: CodecOpts): Uint8Array;
-  decode(
-    buffer: Uint8Array,
-    flags: number,
-    codecOpts: CodecOpts,
-    _packetType: TPacketType,
-  ): PingresPacket;
-} = {
-  encode(_packet: PingresPacket, _codecOpts: CodecOpts): Uint8Array {
-    return PINGRES_PACKET;
-  },
+export function encode(
+  _packet: PingresPacket,
+  _codecOpts: CodecOpts,
+): Uint8Array {
+  return PINGRES_PACKET;
+}
 
-  decode(
-    buffer: Uint8Array,
-    flags: number,
-    codecOpts: CodecOpts,
-    _packetType: TPacketType,
-  ): PingresPacket {
-    hasEmptyFlags(flags);
-    isEmptyBuf(buffer);
-    return {
-      type: PacketType.pingres,
-      protocolLevel: codecOpts.protocolLevel,
-    };
-  },
-};
+export function decode(
+  buffer: Uint8Array,
+  flags: number,
+  codecOpts: CodecOpts,
+  _packetType: PacketType,
+): PingresPacket {
+  hasEmptyFlags(flags);
+  isEmptyBuf(buffer);
+  return {
+    type: PacketType.pingres,
+    protocolLevel: codecOpts.protocolLevel,
+  };
+}

package/mqttPacket/protocolLevels.ts

@@ -2,12 +2,17 @@
  *  MQTT protocol levels
  */
 
-import type { ProtocolLevel } from "./types.ts";
-
-/** available MQTT Protocol levels */
+/** available MQTT Protocol levels
+ * 3.1 = 3
+ * 3.1.1 = 4
+ * 5.0 = 5
+ */
 export const MQTTLevel = {
-  unknown: undefined as ProtocolLevel,
-  v3: 3 as ProtocolLevel,
-  v4: 4 as ProtocolLevel,
-  v5: 5 as ProtocolLevel,
+  unknown: undefined,
+  v3: 3,
+  v4: 4,
+  v5: 5,
 } as const;
+
+export type ProtocolLevel = (typeof MQTTLevel)[keyof typeof MQTTLevel];
+export type ProtocolLevelNoV5 = Exclude<ProtocolLevel, 5>;

package/mqttPacket/pubblishAcks.ts

@@ -1,33 +1,29 @@
-import type {
-  CodecOpts,
-  PacketId,
-  ProtocolLevelNoV5,
-  TPacketType,
-} from "./types.ts";
-import { ReasonCode, type TReasonCode } from "./ReasonCode.ts";
+import type { CodecOpts, PacketId } from "./types.ts";
+import type { ProtocolLevelNoV5 } from "./protocolLevels.ts";
+import { ReasonCode } from "./ReasonCode.ts";
 import type { PubackProperties } from "./Properties.ts";
 import { PacketType } from "./PacketType.ts";
 import { Decoder, DecoderError } from "./decoder.ts";
 import { Encoder } from "./encoder.ts";
 
-export type AckPacketV4<T extends TPacketType> = {
+export type AckPacketV4<T extends PacketType> = {
   type: T;
   protocolLevel: ProtocolLevelNoV5;
   id: PacketId;
 };
 
-export type AckPacketV5<T extends TPacketType> = {
+export type AckPacketV5<T extends PacketType> = {
   type: T;
   protocolLevel: 5;
   id: PacketId;
-  reasonCode?: TReasonCode;
+  reasonCode?: ReasonCode;
   properties?: PubackProperties;
 };
 
 /**
  * all 4 ack packets are identical except for packet type and flags of Pubrel
  */
-export type AckPacket<T extends TPacketType> = AckPacketV4<T> | AckPacketV5<T>;
+export type AckPacket<T extends PacketType> = AckPacketV4<T> | AckPacketV5<T>;
 
 /**
  * PubackPacket is sent to indicate publish complete (QoS 1)
@@ -55,74 +51,64 @@ export type AnyAckPacket =
   | PubrelPacket
   | PubcompPacket;
 
-export const anyAck: {
-  encode(packet: AnyAckPacket, codecOpts: CodecOpts): Uint8Array;
-  decode(
-    buffer: Uint8Array,
-    flags: number,
-    codecOpts: CodecOpts,
-    packetType: TPacketType,
-  ): AnyAckPacket;
-} = {
-  encode(packet: AnyAckPacket, codecOpts: CodecOpts): Uint8Array {
-    const flags = packet.type === PacketType.pubrel ? 2 : 0;
-    const encoder = new Encoder(packet.type);
-    encoder.setInt16(packet.id);
-    if (packet.protocolLevel === 5) {
-      const reasonCode = packet.reasonCode || ReasonCode.success;
-      // if remaining length is less than 1 the value of 0x00 (success) is used.
-      if (
-        reasonCode === ReasonCode.success &&
-        Object.keys(packet.properties || {}).length === 0
-      ) {
-        return encoder.done(flags);
-      }
-      encoder.setReasonCode(reasonCode);
-      encoder.setProperties(
-        packet.properties || {},
-        packet.type,
-        codecOpts.maxOutgoingPacketSize,
-      );
+export function encode(packet: AnyAckPacket, codecOpts: CodecOpts): Uint8Array {
+  const flags = packet.type === PacketType.pubrel ? 2 : 0;
+  const encoder = new Encoder(packet.type);
+  encoder.setInt16(packet.id);
+  if (packet.protocolLevel === 5) {
+    const reasonCode = packet.reasonCode || ReasonCode.success;
+    // if remaining length is less than 1 the value of 0x00 (success) is used.
+    if (
+      reasonCode === ReasonCode.success &&
+      Object.keys(packet.properties || {}).length === 0
+    ) {
+      return encoder.done(flags);
     }
-    return encoder.done(flags);
-  },
+    encoder.seReasonCode(reasonCode);
+    encoder.setProperties(
+      packet.properties || {},
+      packet.type,
+      codecOpts.maxOutgoingPacketSize,
+    );
+  }
+  return encoder.done(flags);
+}
 
-  decode(
-    buffer: Uint8Array,
-    flags: number,
-    codecOpts: CodecOpts,
-    packetType: TPacketType,
-  ): AnyAckPacket {
-    const expectedFlags = packetType === PacketType.pubrel ? 2 : 0;
-    if (flags !== expectedFlags) {
-      throw new DecoderError("Invalid flags");
-    }
-    const decoder = new Decoder(packetType, buffer);
-    const id = decoder.getInt16();
-    if (codecOpts.protocolLevel !== 5) {
-      decoder.done();
-      return {
-        type: packetType as AnyAckPacket["type"],
-        protocolLevel: codecOpts.protocolLevel,
-        id,
-      } as AnyAckPacket;
-    }
-    if (decoder.atEnd()) {
-      return {
-        type: packetType as AnyAckPacket["type"],
-        protocolLevel: 5,
-        id,
-        reasonCode: 0,
-      } as AnyAckPacket;
-    }
-    const reasonCode = decoder.getReasonCode();
-    const properties = decoder.getProperties(packetType);
+export function decode(
+  buffer: Uint8Array,
+  flags: number,
+  codecOpts: CodecOpts,
+  packetType: PacketType,
+): AnyAckPacket {
+  const expectedFlags = packetType === PacketType.pubrel ? 2 : 0;
+  if (flags !== expectedFlags) {
+    throw new DecoderError("Invalid flags");
+  }
+  const decoder = new Decoder(packetType, buffer);
+  const id = decoder.getInt16();
+  if (codecOpts.protocolLevel !== 5) {
+    decoder.done();
+    return {
+      type: packetType as AnyAckPacket["type"],
+      protocolLevel: codecOpts.protocolLevel,
+      id,
+    } as AnyAckPacket;
+  }
+  if (decoder.atEnd()) {
     return {
       type: packetType as AnyAckPacket["type"],
       protocolLevel: 5,
       id,
-      reasonCode,
-      properties,
+      reasonCode: 0,
     } as AnyAckPacket;
-  },
-};
+  }
+  const reasonCode = decoder.geReasonCode();
+  const properties = decoder.getProperties(packetType);
+  return {
+    type: packetType as AnyAckPacket["type"],
+    protocolLevel: 5,
+    id,
+    reasonCode,
+    properties,
+  } as AnyAckPacket;
+}

package/mqttPacket/publish.ts

@@ -1,12 +1,5 @@
-import type {
-  CodecOpts,
-  Dup,
-  Payload,
-  ProtocolLevelNoV5,
-  QoS,
-  Topic,
-  TPacketType,
-} from "./types.ts";
+import type { CodecOpts, Dup, Payload, QoS, Topic } from "./types.ts";
+import type { ProtocolLevelNoV5 } from "./protocolLevels.ts";
 import type { PublishProperties } from "./Properties.ts";
 import { PacketType } from "./PacketType.ts";
 import { BitMask } from "./BitMask.ts";
@@ -18,7 +11,7 @@ import { booleanFlag, Decoder, DecoderError } from "./decoder.ts";
  * from server to subscribers
  */
 export type PublishPacketV4 = {
-  type: TPacketType;
+  type: PacketType;
   protocolLevel: ProtocolLevelNoV5;
   topic: Topic;
   payload: Payload;
@@ -28,7 +21,7 @@ export type PublishPacketV4 = {
   id?: number | undefined;
 };
 export type PublishPacketV5 = {
-  type: TPacketType;
+  type: PacketType;
   protocolLevel: 5;
   topic: Topic;
   payload: Payload;
@@ -38,92 +31,73 @@ export type PublishPacketV5 = {
   id?: number | undefined;
   properties?: PublishProperties | undefined;
 };
-
+/** Publish packet (v4|v5). */
 export type PublishPacket = PublishPacketV4 | PublishPacketV5;
 
-export const publish: {
-  encode(packet: PublishPacket, _codecOpts: CodecOpts): Uint8Array;
-  decode(
-    buffer: Uint8Array,
-    flags: number,
-    codecOpts: CodecOpts,
-    packetType: TPacketType,
-  ): PublishPacket;
-} = {
-  encode(packet: PublishPacket, codecOpts: CodecOpts): Uint8Array {
-    const qos = packet.qos || 0;
+export function encode(
+  packet: PublishPacket,
+  codecOpts: CodecOpts,
+): Uint8Array {
+  const qos = packet.qos || 0;
 
-    const flags = (packet.dup ? BitMask.bit3 : 0) +
-      (qos & 2 ? BitMask.bit2 : 0) +
-      (qos & 1 ? BitMask.bit1 : 0) +
-      (packet.retain ? BitMask.bit0 : 0);
+  const flags = (packet.dup ? BitMask.bit3 : 0) +
+    (qos & 2 ? BitMask.bit2 : 0) +
+    (qos & 1 ? BitMask.bit1 : 0) +
+    (packet.retain ? BitMask.bit0 : 0);
 
-    const encoder = new Encoder(packet.type);
-    encoder.setTopic(packet.topic);
+  const encoder = new Encoder(packet.type);
+  encoder.setUtf8String(packet.topic);
 
-    if (qos === 1 || qos === 2) {
-      if (typeof packet.id !== "number" || packet.id < 1) {
-        throw new EncoderError("when qos is 1 or 2, packet must have id");
-      }
-      encoder.setInt16(packet.id);
+  if (qos === 1 || qos === 2) {
+    if (typeof packet.id !== "number" || packet.id < 1) {
+      throw new EncoderError("when qos is 1 or 2, packet must have id");
     }
+    encoder.setInt16(packet.id);
+  }
 
-    if (packet.protocolLevel === 5) {
-      encoder.setProperties(
-        packet.properties || {},
-        PacketType.publish,
-        codecOpts.maxOutgoingPacketSize,
-      );
-    }
-    encoder.setRemainder(packet.payload);
-    return encoder.done(flags);
-  },
+  if (packet.protocolLevel === 5) {
+    encoder.setProperties(
+      packet.properties || {},
+      PacketType.publish,
+      codecOpts.maxOutgoingPacketSize,
+    );
+  }
+  encoder.setRemainder(packet.payload);
+  return encoder.done(flags);
+}
 
-  decode(
-    buffer: Uint8Array,
-    flags: number,
-    codecOpts: CodecOpts,
-    packetType: TPacketType,
-  ): PublishPacket {
-    const dup = booleanFlag(flags, BitMask.bit3);
-    const qos = (flags & 6) >> 1;
-    const retain = booleanFlag(flags, BitMask.bit0);
+export function decode(
+  buffer: Uint8Array,
+  flags: number,
+  codecOpts: CodecOpts,
+  packetType: PacketType,
+): PublishPacket {
+  const dup = booleanFlag(flags, BitMask.bit3);
+  const qos = (flags & 6) >> 1;
+  const retain = booleanFlag(flags, BitMask.bit0);
 
-    if (qos !== 0 && qos !== 1 && qos !== 2) {
-      throw new DecoderError("Invalid qos");
-    }
+  if (qos !== 0 && qos !== 1 && qos !== 2) {
+    throw new DecoderError("Invalid qos");
+  }
 
-    if (dup && qos === 0) {
-      throw new DecoderError("Invalid qos for possible duplicate");
-    }
+  if (dup && qos === 0) {
+    throw new DecoderError("Invalid qos for possible duplicate");
+  }
 
-    const decoder = new Decoder(packetType, buffer);
-    const topic = decoder.getTopic();
+  const decoder = new Decoder(packetType, buffer);
+  const topic = decoder.getUTF8String();
 
-    let id = undefined;
-    if (qos > 0) {
-      id = decoder.getInt16();
-    }
-    if (codecOpts.protocolLevel === 5) {
-      const properties = decoder.getProperties(PacketType.publish);
-      const payload = decoder.getRemainder();
-      return {
-        type: PacketType.publish,
-        protocolLevel: 5,
-        properties,
-        topic,
-        payload,
-        dup,
-        retain,
-        qos,
-        id,
-      };
-    }
-    // no decoder.done() required because of getRemainder
+  let id = undefined;
+  if (qos > 0) {
+    id = decoder.getInt16();
+  }
+  if (codecOpts.protocolLevel === 5) {
+    const properties = decoder.getProperties(PacketType.publish);
     const payload = decoder.getRemainder();
     return {
       type: PacketType.publish,
-      protocolLevel: codecOpts.protocolLevel,
+      protocolLevel: 5,
+      properties,
       topic,
       payload,
       dup,
@@ -131,5 +105,17 @@ export const publish: {
       qos,
       id,
     };
-  },
-};
+  }
+  // no decoder.done() required because of getRemainder
+  const payload = decoder.getRemainder();
+  return {
+    type: PacketType.publish,
+    protocolLevel: codecOpts.protocolLevel,
+    topic,
+    payload,
+    dup,
+    retain,
+    qos,
+    id,
+  };
+}

package/mqttPacket/publishAcks.test.ts

@@ -2,7 +2,7 @@ import assert from "node:assert/strict";
 import { test } from "node:test";
 
 import { decode, encode, MQTTLevel, PacketType, ReasonCode } from "./mod.ts";
-import type { CodecOpts, TPacketType, TReasonCode } from "./mod.ts";
+import type { CodecOpts } from "./mod.ts";
 
 const codecOptsV4: CodecOpts = {
   protocolLevel: MQTTLevel.v4,
@@ -24,9 +24,9 @@ const packetTypesToTest = [
 ];
 for (const item of packetTypesToTest) {
   const [ackType, label, reasonCode] = item as [
-    TPacketType,
+    PacketType,
     string,
-    TReasonCode,
+    ReasonCode,
   ];
   const ackTypeByte = (ackType << 4) + (ackType === PacketType.pubrel ? 2 : 0);
   test(`encode/decode ${label} v4`, () => {

package/mqttPacket/suback.ts

@@ -1,11 +1,6 @@
-import type {
-  CodecOpts,
-  PacketId,
-  ProtocolLevelNoV5,
-  ReturnCodes,
-  TPacketType,
-  TReasonCode,
-} from "./types.ts";
+import type { CodecOpts, PacketId, ReturnCodes } from "./types.ts";
+import type { ReasonCode } from "./ReasonCode.ts";
+import type { ProtocolLevelNoV5 } from "./protocolLevels.ts";
 import type { SubackProperties } from "./Properties.ts";
 import { PacketType } from "./PacketType.ts";
 import { Encoder } from "./encoder.ts";
@@ -13,18 +8,18 @@ import { Decoder, DecoderError } from "./decoder.ts";
 const validReturnCodes = [0x00, 0x01, 0x02, 0x80];
 
 export type SubackPacketV4 = {
-  type: TPacketType;
+  type: PacketType;
   protocolLevel: ProtocolLevelNoV5;
   id: PacketId;
   returnCodes: ReturnCodes;
 };
 
 export type SubackPacketV5 = {
-  type: TPacketType;
+  type: PacketType;
   protocolLevel: 5;
   id: PacketId;
   properties: SubackProperties;
-  reasonCodes: Array<TReasonCode>;
+  reasonCodes: Array<ReasonCode>;
 };
 
 /**
@@ -33,68 +28,58 @@ export type SubackPacketV5 = {
  */
 export type SubackPacket = SubackPacketV4 | SubackPacketV5;
 
-export const suback: {
-  encode(packet: SubackPacket, _codecOpts: CodecOpts): Uint8Array;
-  decode(
-    buffer: Uint8Array,
-    flags: number,
-    codecOpts: CodecOpts,
-    packetType: TPacketType,
-  ): SubackPacket;
-} = {
-  encode(packet: SubackPacket, codecOpts: CodecOpts): Uint8Array {
-    const flags = 0;
-    const encoder = new Encoder(packet.type);
-    encoder.setInt16(packet.id);
-    if (packet.protocolLevel !== 5) {
-      for (const code of packet.returnCodes) {
-        if (!validReturnCodes.includes(code)) {
-          throw new Error("Invalid return code");
-        }
+export function encode(packet: SubackPacket, codecOpts: CodecOpts): Uint8Array {
+  const flags = 0;
+  const encoder = new Encoder(packet.type);
+  encoder.setInt16(packet.id);
+  if (packet.protocolLevel !== 5) {
+    for (const code of packet.returnCodes) {
+      if (!validReturnCodes.includes(code)) {
+        throw new Error("Invalid return code");
       }
-      encoder.setRemainder(packet.returnCodes);
-      return encoder.done(flags);
-    }
-    encoder.setProperties(
-      packet.properties || {},
-      packet.type,
-      codecOpts.maxOutgoingPacketSize,
-    );
-    for (const code of packet.reasonCodes) {
-      encoder.setReasonCode(code);
     }
+    encoder.setRemainder(packet.returnCodes);
     return encoder.done(flags);
-  },
+  }
+  encoder.setProperties(
+    packet.properties || {},
+    packet.type,
+    codecOpts.maxOutgoingPacketSize,
+  );
+  for (const code of packet.reasonCodes) {
+    encoder.seReasonCode(code);
+  }
+  return encoder.done(flags);
+}
 
-  decode(
-    buffer: Uint8Array,
-    _flags: number,
-    codecOpts: CodecOpts,
-    packetType: TPacketType,
-  ): SubackPacket {
-    const packet = {} as SubackPacket;
-    const decoder = new Decoder(packetType, buffer);
-    packet.type = PacketType.suback;
-    packet.id = decoder.getInt16();
-    packet.protocolLevel = codecOpts.protocolLevel;
+export function decode(
+  buffer: Uint8Array,
+  _flags: number,
+  codecOpts: CodecOpts,
+  packetType: PacketType,
+): SubackPacket {
+  const packet = {} as SubackPacket;
+  const decoder = new Decoder(packetType, buffer);
+  packet.type = PacketType.suback;
+  packet.id = decoder.getInt16();
+  packet.protocolLevel = codecOpts.protocolLevel;
 
-    if (packet.protocolLevel !== 5) {
-      const payload = decoder.getRemainder();
-      packet.returnCodes = [];
-      for (const code of payload) {
-        if (!validReturnCodes.includes(code)) {
-          throw new DecoderError("Invalid return code");
-        }
-        packet.returnCodes.push(code);
+  if (packet.protocolLevel !== 5) {
+    const payload = decoder.getRemainder();
+    packet.returnCodes = [];
+    for (const code of payload) {
+      if (!validReturnCodes.includes(code)) {
+        throw new DecoderError("Invalid return code");
       }
-      return packet;
-    }
-    packet.properties = decoder.getProperties(PacketType.suback);
-    packet.reasonCodes = [];
-    while (!decoder.atEnd()) {
-      const code = decoder.getReasonCode();
-      packet.reasonCodes.push(code);
+      packet.returnCodes.push(code);
     }
     return packet;
-  },
-};
+  }
+  packet.properties = decoder.getProperties(PacketType.suback);
+  packet.reasonCodes = [];
+  while (!decoder.atEnd()) {
+    const code = decoder.geReasonCode();
+    packet.reasonCodes.push(code);
+  }
+  return packet;
+}