@seriousme/opifex 1.11.3 → 2.0.3

package/mqttPacket/connect.ts

@@ -2,12 +2,11 @@ import type {
   ClientId,
   CodecOpts,
   Payload,
-  ProtocolLevel,
-  ProtocolLevelNoV5,
   QoS,
   Topic,
   TPacketType,
 } from "./types.ts";
+import type { ProtocolLevel, ProtocolLevelNoV5 } from "./protocolLevels.ts";
 import type { ConnectProperties, WillProperties } from "./Properties.ts";
 import { PropertySetType } from "./Properties.ts";
 import { PacketType } from "./PacketType.ts";
@@ -76,221 +75,215 @@ function invalidProtocolName(version: number, name: string): boolean {
   return true;
 }
 
-export const connect: {
-  encode(packet: ConnectPacket, _codecOpts: CodecOpts): Uint8Array;
-  decode(
-    buffer: Uint8Array,
-    flags: number,
-    codecOpts: CodecOpts,
-    packetType: TPacketType,
-  ): ConnectPacket;
-} = {
-  encode(packet: ConnectPacket, codecOpts: CodecOpts): Uint8Array {
-    const flags = 0;
+export function encode(
+  packet: ConnectPacket,
+  codecOpts: CodecOpts,
+): Uint8Array {
+  const flags = 0;
 
-    if (typeof packet.protocolLevel !== "number") {
-      throw new EncoderError("Protocol level must be a number");
-    }
-    const protocolLevel = packet.protocolLevel || 4;
-    if (protocolLevel < 3 || protocolLevel > 5) {
-      throw new EncoderError("Unsupported protocol level");
-    }
-    const protocolName = protocolLevel > 3 ? "MQTT" : "MQIsdp";
-    const clientId = packet.clientId || "";
-    const usernameFlag = packet.username !== undefined;
-    if (protocolLevel === 3 && clientId === "") {
-      throw new EncoderError("Client id required for protocol level 3");
-    }
-    const passwordFlag = usernameFlag && packet.password !== undefined;
-    const willRetain = !!packet.will?.retain;
-    const willQoS = packet.will?.qos || 0;
-    const willFlag = packet.will !== undefined;
-    if (willFlag) {
-      if (packet.will?.topic === undefined) {
-        throw new EncoderError("Will topic must be defined");
-      }
-      if (packet.will?.payload === undefined) {
-        throw new EncoderError("Will payload must be defined");
-      }
+  // deno-coverage-ignore-start
+  if (typeof packet.protocolLevel !== "number") {
+    throw new EncoderError("Protocol level must be a number");
+  }
+  const protocolLevel = packet.protocolLevel || 4;
+  if (protocolLevel < 3 || protocolLevel > 5) {
+    throw new EncoderError("Unsupported protocol level");
+  }
+  // deno-coverage-ignore-stop
+  const protocolName = protocolLevel > 3 ? "MQTT" : "MQIsdp";
+  const clientId = packet.clientId || "";
+  const usernameFlag = packet.username !== undefined;
+  if (protocolLevel === 3 && clientId === "") {
+    throw new EncoderError("Client id required for protocol level 3");
+  }
+  const passwordFlag = usernameFlag && packet.password !== undefined;
+  const willRetain = !!packet.will?.retain;
+  const willQoS = packet.will?.qos || 0;
+  const willFlag = packet.will !== undefined;
+  if (willFlag) {
+    if (packet.will?.topic === undefined) {
+      throw new EncoderError("Will topic must be defined");
     }
-    const cleanSession = packet.clean !== false;
-    if (!cleanSession && (clientId === "")) {
-      throw new EncoderError("Client id required for clean session");
+    if (packet.will?.payload === undefined) {
+      throw new EncoderError("Will payload must be defined");
     }
-    const connectFlags = (usernameFlag ? BitMask.bit7 : 0) +
-      (passwordFlag ? BitMask.bit6 : 0) +
-      (willRetain ? BitMask.bit5 : 0) +
-      (willQoS & 2 ? BitMask.bit4 : 0) +
-      (willQoS & 1 ? BitMask.bit3 : 0) +
-      (willFlag ? BitMask.bit2 : 0) +
-      (cleanSession ? BitMask.bit1 : 0);
-    const keepAlive = packet.keepAlive || 0;
-    const bridgeMode = !!packet.bridgeMode;
-    const rawProtocolLevel = bridgeMode ? protocolLevel + 128 : protocolLevel;
+  }
+  const cleanSession = packet.clean !== false;
+  if (!cleanSession && (clientId === "")) {
+    throw new EncoderError("Client id required for non-clean session");
+  }
+  const connectFlags = (usernameFlag ? BitMask.bit7 : 0) +
+    (passwordFlag ? BitMask.bit6 : 0) +
+    (willRetain ? BitMask.bit5 : 0) +
+    (willQoS & 2 ? BitMask.bit4 : 0) +
+    (willQoS & 1 ? BitMask.bit3 : 0) +
+    (willFlag ? BitMask.bit2 : 0) +
+    (cleanSession ? BitMask.bit1 : 0);
+  const keepAlive = packet.keepAlive || 0;
+  const bridgeMode = !!packet.bridgeMode;
+  const rawProtocolLevel = bridgeMode ? protocolLevel + 128 : protocolLevel;
 
-    const encoder = new Encoder(packet.type);
-    encoder
-      .setUtf8String(protocolName)
-      .setByte(rawProtocolLevel)
-      .setByte(connectFlags)
-      .setInt16(keepAlive);
+  const encoder = new Encoder(packet.type);
+  encoder
+    .setUtf8String(protocolName)
+    .setByte(rawProtocolLevel)
+    .setByte(connectFlags)
+    .setInt16(keepAlive);
+  if (packet.protocolLevel === 5) {
+    encoder.setProperties(
+      packet.properties || {},
+      PropertySetType.connect,
+      codecOpts.maxOutgoingPacketSize,
+    );
+  }
+  encoder.setUtf8String(clientId);
+
+  if (
+    packet.will !== undefined && packet.will.topic !== undefined &&
+    packet.will.payload !== undefined
+  ) {
     if (packet.protocolLevel === 5) {
       encoder.setProperties(
-        packet.properties || {},
-        PropertySetType.connect,
+        packet.will?.properties || {},
+        PropertySetType.will,
         codecOpts.maxOutgoingPacketSize,
       );
     }
-    encoder.setUtf8String(clientId);
-
-    if (
-      packet.will !== undefined && packet.will.topic !== undefined &&
-      packet.will.payload !== undefined
-    ) {
-      if (packet.protocolLevel === 5) {
-        encoder.setProperties(
-          packet.will?.properties || {},
-          PropertySetType.will,
-          codecOpts.maxOutgoingPacketSize,
-        );
-      }
-      encoder.setTopic(packet.will.topic).setByteArray(packet.will.payload);
-    }
+    encoder.setUtf8String(packet.will.topic);
+    encoder.setByteArray(packet.will.payload);
+  }
 
-    if (packet.username !== undefined) {
-      encoder.setUtf8String(packet.username);
-    }
+  if (packet.username !== undefined) {
+    encoder.setUtf8String(packet.username);
+  }
 
-    if (passwordFlag && packet.password !== undefined) {
-      encoder.setByteArray(packet.password);
-    }
-    return encoder.done(flags);
-  },
+  if (passwordFlag && packet.password !== undefined) {
+    encoder.setByteArray(packet.password);
+  }
+  return encoder.done(flags);
+}
 
-  decode(
-    buffer: Uint8Array,
-    flags: number,
-    _codecOpts: CodecOpts,
-    packetType: TPacketType,
-  ): ConnectPacket {
-    const decoder = new Decoder(packetType, buffer);
-    const protocolName = decoder.getUTF8String();
-    const rawProtocolLevel = decoder.getByte();
-    const bridgeMode = rawProtocolLevel > 128;
-    const protocolLevel = bridgeMode
-      ? rawProtocolLevel - 128
-      : rawProtocolLevel;
+export function decode(
+  buffer: Uint8Array,
+  flags: number,
+  _codecOpts: CodecOpts,
+  packetType: TPacketType,
+): ConnectPacket {
+  const decoder = new Decoder(packetType, buffer);
+  const protocolName = decoder.getUTF8String();
+  const rawProtocolLevel = decoder.getByte();
+  const bridgeMode = rawProtocolLevel > 128;
+  const protocolLevel = bridgeMode ? rawProtocolLevel - 128 : rawProtocolLevel;
 
-    if (invalidProtocolName(protocolLevel, protocolName)) {
-      throw new DecoderError("Invalid protocol name or level");
-    }
+  if (invalidProtocolName(protocolLevel, protocolName)) {
+    throw new DecoderError("Invalid protocol name or level");
+  }
 
-    const connectFlags = decoder.getByte();
+  const connectFlags = decoder.getByte();
 
-    const usernameFlag = booleanFlag(connectFlags, BitMask.bit7);
-    const passwordFlag = booleanFlag(connectFlags, BitMask.bit6);
-    const willRetain = booleanFlag(connectFlags, BitMask.bit5);
-    const willQoS = (connectFlags & (BitMask.bit4 + BitMask.bit3)) >> 3;
-    const willFlag = booleanFlag(connectFlags, BitMask.bit2);
-    const cleanSession = booleanFlag(connectFlags, BitMask.bit1);
-    const reservedBit = booleanFlag(connectFlags, BitMask.bit0);
+  const usernameFlag = booleanFlag(connectFlags, BitMask.bit7);
+  const passwordFlag = booleanFlag(connectFlags, BitMask.bit6);
+  const willRetain = booleanFlag(connectFlags, BitMask.bit5);
+  const willQoS = (connectFlags & (BitMask.bit4 + BitMask.bit3)) >> 3;
+  const willFlag = booleanFlag(connectFlags, BitMask.bit2);
+  const cleanSession = booleanFlag(connectFlags, BitMask.bit1);
+  const reservedBit = booleanFlag(connectFlags, BitMask.bit0);
 
-    hasEmptyFlags(flags);
-    // The Server MUST validate that the reserved flag in the CONNECT Control Packet
-    // is set to zero and disconnect the Client if it is not zero [MQTT-3.1.2-3].
-    if (reservedBit) {
-      throw new DecoderError("Invalid reserved bit");
-    }
+  hasEmptyFlags(flags);
+  // The Server MUST validate that the reserved flag in the CONNECT Control Packet
+  // is set to zero and disconnect the Client if it is not zero [MQTT-3.1.2-3].
+  if (reservedBit) {
+    throw new DecoderError("Invalid reserved bit");
+  }
 
-    if (willQoS !== 0 && willQoS !== 1 && willQoS !== 2) {
-      throw new DecoderError("Invalid will qos");
-    }
+  if (willQoS !== 0 && willQoS !== 1 && willQoS !== 2) {
+    throw new DecoderError("Invalid will qos");
+  }
 
-    if (!usernameFlag && passwordFlag) {
-      throw new DecoderError("Password without username");
-    }
+  if (!usernameFlag && passwordFlag) {
+    throw new DecoderError("Password without username");
+  }
 
-    const keepAlive = decoder.getInt16();
-    const isV5 = protocolLevel === 5;
-    let properties;
+  const keepAlive = decoder.getInt16();
+  const isV5 = protocolLevel === 5;
+  let properties;
+  if (isV5) {
+    properties = decoder.getProperties(PropertySetType.connect);
+  }
+  const clientId = decoder.getUTF8String();
+  let willProperties;
+  let willTopic;
+  let willPayload;
+  if (willFlag) {
     if (isV5) {
-      properties = decoder.getProperties(PropertySetType.connect);
-    }
-    const clientId = decoder.getUTF8String();
-    let willProperties;
-    let willTopic;
-    let willPayload;
-    if (willFlag) {
-      if (isV5) {
-        willProperties = decoder.getProperties(PropertySetType.will);
-      }
-      willTopic = decoder.getTopic();
-      willPayload = decoder.getByteArray();
+      willProperties = decoder.getProperties(PropertySetType.will);
     }
+    willTopic = decoder.getUTF8String();
+    willPayload = decoder.getByteArray();
+  }
 
-    let username;
-    let password;
-    if (usernameFlag) {
-      username = decoder.getUTF8String();
-    }
+  let username;
+  let password;
+  if (usernameFlag) {
+    username = decoder.getUTF8String();
+  }
 
-    if (passwordFlag) {
-      password = decoder.getByteArray();
-    }
+  if (passwordFlag) {
+    password = decoder.getByteArray();
+  }
 
-    decoder.done();
-    if (!willFlag && (willQoS !== 0 || willRetain === true)) {
-      throw new DecoderError(
-        "Will QoS must be 0 and Will retain to false when Will flag is false",
-      );
-    }
+  decoder.done();
+  if (!willFlag && (willQoS !== 0 || willRetain === true)) {
+    throw new DecoderError(
+      "Will QoS must be 0 and Will retain to false when Will flag is false",
+    );
+  }
 
-    if (clientId.length === 0 && cleanSession === false) {
-      throw new DecoderError("Clean session must be true if clientID is empty");
-    }
+  if (clientId.length === 0 && cleanSession === false) {
+    throw new DecoderError("Clean session must be true if clientID is empty");
+  }
 
-    let bridgeModeProp = {};
-    if (bridgeMode) {
-      bridgeModeProp = { bridgeMode };
-    }
-    const commonProps = {
-      type: PacketType.connect,
-      protocolName: protocolName,
-      clientId: clientId,
-      username,
-      password: password ? password : undefined,
-      clean: cleanSession,
-      keepAlive,
-      ...bridgeModeProp,
-    };
+  let bridgeModeProp = {};
+  if (bridgeMode) {
+    bridgeModeProp = { bridgeMode };
+  }
+  const commonProps = {
+    type: PacketType.connect,
+    protocolName: protocolName,
+    clientId: clientId,
+    username,
+    password: password ? password : undefined,
+    clean: cleanSession,
+    keepAlive,
+    ...bridgeModeProp,
+  };
 
-    if (isV5) {
-      return {
-        ...commonProps,
-        protocolLevel: 5,
-        will: willFlag
-          ? {
-            topic: willTopic || "",
-            payload: willPayload || Uint8Array.from([0]),
-            retain: willRetain,
-            qos: willQoS,
-            properties: willProperties,
-          }
-          : undefined,
-        properties,
-      };
-    }
+  if (isV5) {
     return {
       ...commonProps,
-      protocolLevel: protocolLevel as ProtocolLevel,
+      protocolLevel: 5,
       will: willFlag
         ? {
           topic: willTopic || "",
           payload: willPayload || Uint8Array.from([0]),
           retain: willRetain,
           qos: willQoS,
+          properties: willProperties,
         }
         : undefined,
+      properties,
     };
-  },
-};
+  }
+  return {
+    ...commonProps,
+    protocolLevel: protocolLevel as ProtocolLevel,
+    will: willFlag
+      ? {
+        topic: willTopic || "",
+        payload: willPayload || Uint8Array.from([0]),
+        retain: willRetain,
+        qos: willQoS,
+      }
+      : undefined,
+  };
+}

package/mqttPacket/decoder.test.ts

@@ -77,45 +77,6 @@ test("decode string", () => {
   assert.deepStrictEqual(decoder.done(), true);
 });
 
-test("decode topic", () => {
-  const str = "hello world";
-  const byteArray = utf8encoder.encode(str);
-  const len = byteArray.length;
-  const decoder = new Decoder(
-    packetType,
-    Uint8Array.from([0x00, len, ...byteArray]),
-  );
-  assert.deepStrictEqual(decoder.getTopic(), str);
-  assert.deepStrictEqual(decoder.done(), true);
-});
-
-test("Topic too short", () => {
-  const decoder = new Decoder(packetType, Uint8Array.from([0x00, 0]));
-  assert.throws(
-    () => decoder.getTopic(),
-    Error,
-    "Topic must contain valid UTF-8 and contain more than 1 byte and no wildcards",
-  );
-});
-
-test("Invalid topic", () => {
-  const decoder = new Decoder(packetType, Uint8Array.from([0x00, 0x01, 0x00]));
-  assert.throws(
-    () => decoder.getTopic(),
-    Error,
-    "Topic must contain valid UTF-8 and contain more than 1 byte and no wildcards",
-  );
-});
-
-test("Invalid topicFilter", () => {
-  const decoder = new Decoder(packetType, Uint8Array.from([0x00, 0x01, 0x00]));
-  assert.throws(
-    () => decoder.getTopic(),
-    Error,
-    "Topic must contain valid UTF-8 and contain more than 1 byte and no wildcards",
-  );
-});
-
 test("Buffer too short", () => {
   const str = "hello world";
   const byteArray = utf8encoder.encode(str);

package/mqttPacket/decoder.ts

@@ -1,12 +1,10 @@
 import type {
   TBitMask,
-  Topic,
-  TopicFilter,
   TPacketType,
   TReasonCode,
   UTF8StringPair,
 } from "./types.ts";
-import { invalidTopic, invalidTopicFilter } from "./validators.ts";
+import { invalidUTF8 } from "./validators.ts";
 import { isValidReasonCode } from "./ReasonCode.ts";
 import type {
   Mqttv5PropertyTypesNoUser,
@@ -170,6 +168,11 @@ export class Decoder {
    */
   getUTF8String(): string {
     const str = utf8Decoder.decode(this.getByteArray());
+    if (invalidUTF8(str)) {
+      throw new DecoderError(
+        "String must contain valid UTF-8",
+      );
+    }
     return str;
   }
 
@@ -178,41 +181,11 @@ export class Decoder {
    * @returns The decoded UTF-8 pair as [name,value]
    */
   getUTF8StringPair(): UTF8StringPair {
-    const name = utf8Decoder.decode(this.getByteArray());
-    const value = utf8Decoder.decode(this.getByteArray());
+    const name = this.getUTF8String();
+    const value = this.getUTF8String();
     return [name, value];
   }
 
-  /**
-   * Gets a topic from the buffer
-   * @returns The decoded topic
-   * @throws {DecoderError} If topic is invalid
-   */
-  getTopic(): Topic {
-    const topic = this.getUTF8String();
-    if (invalidTopic(topic)) {
-      throw new DecoderError(
-        "Topic must contain valid UTF-8 and contain more than 1 byte and no wildcards",
-      );
-    }
-    return topic;
-  }
-
-  /**
-   * Gets a topic filter from the buffer
-   * @returns The decoded topic filter
-   * @throws {DecoderError} If topic filter is invalid
-   */
-  getTopicFilter(): TopicFilter {
-    const topicFilter = this.getUTF8String();
-    if (invalidTopicFilter(topicFilter)) {
-      throw new DecoderError(
-        "Topicfilter must contain valid UTF-8 and contain more than 1 byte and valid wildcards",
-      );
-    }
-    return topicFilter;
-  }
-
   /**
    * Gets the remaining bytes from the current position to the end
    * @returns The remaining bytes as a subarray

package/mqttPacket/disconnect.ts

@@ -1,11 +1,7 @@
 import { PacketType } from "./PacketType.ts";
 import { Decoder, hasEmptyFlags, isEmptyBuf } from "./decoder.ts";
-import type {
-  CodecOpts,
-  ProtocolLevelNoV5,
-  TPacketType,
-  TReasonCode,
-} from "./types.ts";
+import type { CodecOpts, TPacketType, TReasonCode } from "./types.ts";
+import type { ProtocolLevelNoV5 } from "./protocolLevels.ts";
 import type { DisconnectProperties } from "./Properties.ts";
 import { Encoder } from "./encoder.ts";
 import { ReasonCode } from "./ReasonCode.ts";
@@ -30,71 +26,64 @@ export type DisconnectPacket = DisconnectPacketv4 | DisconnectPacketv5;
 
 const DISCONNECT_PACKET = new Uint8Array([PacketType.disconnect << 4, 0]);
 
-export const disconnect: {
-  encode(_packet: DisconnectPacket, _codecOpts: CodecOpts): Uint8Array;
-  decode(
-    buffer: Uint8Array,
-    _flags: number,
-    codecOpts: CodecOpts,
-    packetType: TPacketType,
-  ): DisconnectPacket;
-} = {
-  encode(packet: DisconnectPacket, codecOpts: CodecOpts): Uint8Array {
-    if (packet.protocolLevel !== 5) {
-      return DISCONNECT_PACKET;
-    }
-    const reasonCode = packet.reasonCode || ReasonCode.normalDisconnection;
-    const encoder = new Encoder(packet.type);
-    // see MQTT v5 3.14.2.1
-    // if remaining length is less than 1 the value of 0x00 (normal disconnect) is used.
-    if (
-      reasonCode === ReasonCode.normalDisconnection &&
-      Object.keys(packet.properties || {}).length === 0
-    ) {
-      return encoder.done(0);
-    }
-    encoder
-      .setReasonCode(reasonCode);
-    if (packet.properties) {
-      encoder.setProperties(
-        packet.properties,
-        packet.type,
-        codecOpts.maxOutgoingPacketSize,
-      );
-    }
+export function encode(
+  packet: DisconnectPacket,
+  codecOpts: CodecOpts,
+): Uint8Array {
+  if (packet.protocolLevel !== 5) {
+    return DISCONNECT_PACKET;
+  }
+  const reasonCode = packet.reasonCode || ReasonCode.normalDisconnection;
+  const encoder = new Encoder(packet.type);
+  // see MQTT v5 3.14.2.1
+  // if remaining length is less than 1 the value of 0x00 (normal disconnect) is used.
+  if (
+    reasonCode === ReasonCode.normalDisconnection &&
+    Object.keys(packet.properties || {}).length === 0
+  ) {
     return encoder.done(0);
-  },
+  }
+  encoder
+    .setReasonCode(reasonCode);
+  if (packet.properties) {
+    encoder.setProperties(
+      packet.properties,
+      packet.type,
+      codecOpts.maxOutgoingPacketSize,
+    );
+  }
+  return encoder.done(0);
+}
 
-  decode(
-    buffer: Uint8Array,
-    flags: number,
-    codecOpts,
-    packetType: TPacketType,
-  ): DisconnectPacket {
-    hasEmptyFlags(flags);
-    if (codecOpts.protocolLevel !== 5) {
-      isEmptyBuf(buffer);
-      return {
-        type: PacketType.disconnect,
-        protocolLevel: codecOpts.protocolLevel,
-      };
-    }
-    const decoder = new Decoder(packetType, buffer);
-    if (decoder.atEnd()) {
-      return {
-        type: PacketType.disconnect,
-        protocolLevel: 5,
-        reasonCode: 0,
-      };
-    }
-    const reasonCode = decoder.getReasonCode();
-    const properties = decoder.getProperties(PacketType.disconnect);
-    decoder.done();
+export function decode(
+  buffer: Uint8Array,
+  flags: number,
+  codecOpts: CodecOpts,
+  packetType: TPacketType,
+): DisconnectPacket {
+  hasEmptyFlags(flags);
+  if (codecOpts.protocolLevel !== 5) {
+    isEmptyBuf(buffer);
+    return {
+      type: PacketType.disconnect,
+      protocolLevel: codecOpts.protocolLevel,
+    };
+  }
+  const decoder = new Decoder(packetType, buffer);
+  if (decoder.atEnd()) {
     return {
       type: PacketType.disconnect,
       protocolLevel: 5,
-      reasonCode,
-      properties,
+      reasonCode: 0,
     };
-  },
-};
+  }
+  const reasonCode = decoder.getReasonCode();
+  const properties = decoder.getProperties(PacketType.disconnect);
+  decoder.done();
+  return {
+    type: PacketType.disconnect,
+    protocolLevel: 5,
+    reasonCode,
+    properties,
+  };
+}