@seriousme/opifex 1.9.3 → 1.10.1

package/mqttConn/mqttConn.ts

@@ -2,12 +2,18 @@
  * @module mqttConn
  */
 
+import type {
+  AnyPacket,
+  CodecOpts,
+  LengthDecoderResult,
+  ProtocolLevel,
+} from "../mqttPacket/mod.ts";
+
 import {
-  type AnyPacket,
   decodePayload,
   encode,
   getLengthDecoder,
-  type LengthDecoderResult,
+  MQTTLevel,
 } from "../mqttPacket/mod.ts";
 
 import { assert } from "../utils/mod.ts";
@@ -23,6 +29,8 @@ export const MqttConnError = {
   UnexpectedEof: "Unexpected EOF",
 } as const;
 
+const DEFAULT_MAX_PACKETSIZE = 2 * 1024 * 1024; // 2MB
+
 /**
  * Interface for MQTT connection handling
  */
@@ -74,13 +82,13 @@ async function readFull(conn: Conn, buf: Uint8Array): Promise<void> {
 /**
  * Read a complete MQTT packet from the connection
  * @param conn Connection to read from
- * @param maxPacketSize Maximum allowed packet size
+ * @param maxIncomingPacketSize Maximum allowed packet size
  * @returns Decoded MQTT packet
  * @throws Error if packet is invalid or too large
  */
 export async function readPacket(
   conn: Conn,
-  maxPacketSize: number,
+  codecOpts: CodecOpts,
 ): Promise<AnyPacket> {
   // fixed header is 1 byte of type + flags
   // + a maximum of 4 bytes to encode the remaining length
@@ -93,11 +101,15 @@ export async function readPacket(
   } while (!result.done);
 
   const remainingLength = result.length;
-  assert(remainingLength < maxPacketSize - 1, MqttConnError.packetTooLarge);
+  const maxIncomingPacketSize = codecOpts.maxIncomingPacketSize;
+  assert(
+    remainingLength < maxIncomingPacketSize - 1,
+    MqttConnError.packetTooLarge,
+  );
   const packetBuf = new Uint8Array(remainingLength);
   // read the rest of the packet
   await readFull(conn, packetBuf);
-  const packet = decodePayload(firstByte, packetBuf);
+  const packet = decodePayload(firstByte, packetBuf, codecOpts);
   assert(packet !== null, MqttConnError.UnexpectedEof);
   return packet;
 }
@@ -108,8 +120,8 @@ export async function readPacket(
 export class MqttConn implements IMqttConn {
   /** Underlying connection */
   readonly conn: Conn;
-  /** Maximum allowed packet size */
-  private readonly maxPacketSize: number;
+  /** codecOpts */
+  codecOpts: CodecOpts;
   /** Reason for connection closure if any */
   private _reason: string | undefined = undefined;
   /** Whether connection is closed */
@@ -119,17 +131,25 @@ export class MqttConn implements IMqttConn {
    * Create new MQTT connection
    * @param options Connection options
    * @param options.conn Underlying socket connection
-   * @param options.maxPacketSize Maximum allowed packet size (default 2MB)
+   * @param options.maxIncomingPacketSize Maximum allowed incoming packet size (default 2MB)
+   * @param options.maxOutGoingPacketSize Maximum allowed outgoing packet size (default 2MB)
+   * @param options.protocolLevel Supported protocolLevel
    */
   constructor({
     conn,
-    maxPacketSize,
+    maxIncomingPacketSize = DEFAULT_MAX_PACKETSIZE,
+    protocolLevel = MQTTLevel.unknown,
   }: {
     conn: SockConn;
-    maxPacketSize?: number;
+    maxIncomingPacketSize?: number;
+    protocolLevel?: ProtocolLevel;
   }) {
     this.conn = new Conn(conn);
-    this.maxPacketSize = maxPacketSize || 2 * 1024 * 1024;
+    this.codecOpts = {
+      maxIncomingPacketSize,
+      maxOutgoingPacketSize: maxIncomingPacketSize,
+      protocolLevel,
+    };
   }
 
   /** Get reason for connection closure */
@@ -137,6 +157,14 @@ export class MqttConn implements IMqttConn {
     return this._reason;
   }
 
+  /** Get remoteAdress */
+  get remoteAddress(): string {
+    if (this.conn.remoteAddr?.transport === "tcp") {
+      return this.conn.remoteAddr.hostname;
+    }
+    return "unknown";
+  }
+
   /**
    * Async iterator for receiving packets
    * @yields MQTT packets
@@ -144,7 +172,10 @@ export class MqttConn implements IMqttConn {
   async *[Symbol.asyncIterator](): AsyncIterableIterator<AnyPacket> {
     while (!this._isClosed) {
       try {
-        yield await readPacket(this.conn, this.maxPacketSize);
+        yield await readPacket(
+          this.conn,
+          this.codecOpts,
+        );
       } catch (err) {
         if (err instanceof Error) {
           if (err.name === "PartialReadError") {
@@ -165,7 +196,7 @@ export class MqttConn implements IMqttConn {
    */
   async send(data: AnyPacket): Promise<void> {
     try {
-      await this.conn.write(encode(data));
+      await this.conn.write(encode(data, this.codecOpts));
     } catch (err) {
       if (err instanceof Error) {
         this._reason = err.message;

package/mqttPacket/PacketType.ts

@@ -17,6 +17,7 @@ export const PacketType = {
   pingreq: 12,
   pingres: 13,
   disconnect: 14,
+  auth: 15,
 } as const;
 
 /**

package/mqttPacket/Properties.ts

@@ -0,0 +1,276 @@
+import { PacketType } from "./PacketType.ts";
+import type { InvertRecord, UTF8StringPair } from "./types.ts";
+
+export const PropertySetType = {
+  ...PacketType,
+  will: 100,
+} as const;
+
+export type TPropertySetType =
+  typeof PropertySetType[keyof typeof PropertySetType];
+
+export const propertyKind = {
+  boolean: 0, // its a byte in the MQTT standard, but for convenience we convert to boolean
+  byte: 1,
+  int16: 2,
+  int32: 3,
+  varInt: 4,
+  byteArray: 5,
+  utf8string: 6,
+  utf8StringPairs: 7,
+  varIntArray: 8,
+} as const;
+
+export const propertyToId = {
+  payloadFormatIndicator: 0x01,
+  messageExpiryInterval: 0x02,
+  contentType: 0x03,
+  responseTopic: 0x08,
+  correlationData: 0x09,
+  subscriptionIdentifier: 0x0b,
+  // special case,placeholder to encode decode multiple subscription identifiers
+  subscriptionIdentifiers: 0xff,
+  sessionExpiryInterval: 0x11,
+  assignedClientIdentifier: 0x12,
+  serverKeepAlive: 0x13,
+  authenticationMethod: 0x15,
+  authenticationData: 0x16,
+  requestProblemInformation: 0x17,
+  willDelayInterval: 0x18,
+  requestResponseInformation: 0x19,
+  responseInformation: 0x1a,
+  serverReference: 0x1c,
+  reasonString: 0x1f,
+  receiveMaximum: 0x21,
+  topicAliasMaximum: 0x22,
+  topicAlias: 0x23,
+  maximumQos: 0x24,
+  retainAvailable: 0x25,
+  userProperty: 0x26,
+  maximumPacketSize: 0x27,
+  wildcardSubscriptionAvailable: 0x28,
+  subscriptionIdentifierAvailable: 0x29,
+  sharedSubscriptionAvailable: 0x2a,
+} as const;
+
+type PropertyNames = keyof typeof propertyToId;
+// A helper type to convert a tuple of numbers to a union of strings
+
+export const propertyToKind = {
+  [propertyToId.payloadFormatIndicator]: propertyKind.boolean,
+  [propertyToId.messageExpiryInterval]: propertyKind.int32,
+  [propertyToId.contentType]: propertyKind.utf8string,
+  [propertyToId.responseTopic]: propertyKind.utf8string,
+  [propertyToId.correlationData]: propertyKind.byteArray,
+  [propertyToId.subscriptionIdentifier]: propertyKind.varInt,
+  [propertyToId.subscriptionIdentifiers]: propertyKind.varIntArray,
+  [propertyToId.sessionExpiryInterval]: propertyKind.int32,
+  [propertyToId.assignedClientIdentifier]: propertyKind.utf8string,
+  [propertyToId.serverKeepAlive]: propertyKind.int16,
+  [propertyToId.authenticationMethod]: propertyKind.utf8string,
+  [propertyToId.authenticationData]: propertyKind.byteArray,
+  [propertyToId.requestProblemInformation]: propertyKind.boolean,
+  [propertyToId.willDelayInterval]: propertyKind.int32,
+  [propertyToId.requestResponseInformation]: propertyKind.boolean,
+  [propertyToId.responseInformation]: propertyKind.utf8string,
+  [propertyToId.serverReference]: propertyKind.utf8string,
+  [propertyToId.reasonString]: propertyKind.utf8string,
+  [propertyToId.receiveMaximum]: propertyKind.int16,
+  [propertyToId.topicAliasMaximum]: propertyKind.int16,
+  [propertyToId.topicAlias]: propertyKind.int16,
+  [propertyToId.maximumQos]: propertyKind.byte,
+  [propertyToId.retainAvailable]: propertyKind.boolean,
+  [propertyToId.userProperty]: propertyKind.utf8StringPairs,
+  [propertyToId.maximumPacketSize]: propertyKind.int32,
+  [propertyToId.wildcardSubscriptionAvailable]: propertyKind.boolean,
+  [propertyToId.subscriptionIdentifierAvailable]: propertyKind.boolean,
+  [propertyToId.sharedSubscriptionAvailable]: propertyKind.boolean,
+} as const;
+
+export type UserPropertyType = Array<UTF8StringPair>;
+export type SubscriptionIdentifiersType = Array<number>;
+
+type PropertyKindMap = {
+  [propertyKind.boolean]: boolean;
+  [propertyKind.byte]: number;
+  [propertyKind.int16]: number;
+  [propertyKind.int32]: number;
+  [propertyKind.varInt]: number;
+  [propertyKind.byteArray]: Uint8Array;
+  [propertyKind.utf8string]: string;
+  [propertyKind.utf8StringPairs]: UserPropertyType;
+  [propertyKind.varIntArray]: SubscriptionIdentifiersType;
+};
+
+type Mqttv5PropertyType<K extends number> = K extends keyof PropertyKindMap
+  ? PropertyKindMap[K]
+  : never;
+
+export type Mqttv5PropertyTypes = PropertyKindMap[keyof PropertyKindMap];
+export type Mqttv5PropertyTypesNoUser = Exclude<
+  Mqttv5PropertyTypes,
+  UserPropertyType
+>;
+
+// First, create a type for all valid property numbers
+export type ValidPropertyNumber =
+  (typeof propertyToId)[keyof typeof propertyToId];
+// Then, create a mapped type that iterates over the property names
+// and uses propertyToKind to look up the correct TypeScript type.
+
+type AllMqttv5Properties = {
+  [K in PropertyNames]?: Mqttv5PropertyType<
+    typeof propertyToKind[typeof propertyToId[K]]
+  >;
+};
+
+type PropertyByNumberType = InvertRecord<typeof propertyToId>;
+
+export const propertyByNumber = Object.fromEntries(
+  Object.entries(propertyToId).map(
+    ([k, v]) => [v, k],
+  ),
+) as PropertyByNumberType;
+
+export const PropertyByPropertySetType = {
+  [PropertySetType.reserved]: [],
+  [PropertySetType.connect]: [
+    propertyToId.sessionExpiryInterval,
+    propertyToId.authenticationMethod,
+    propertyToId.authenticationData,
+    propertyToId.requestProblemInformation,
+    propertyToId.requestResponseInformation,
+    propertyToId.receiveMaximum,
+    propertyToId.topicAliasMaximum,
+    propertyToId.userProperty,
+    propertyToId.maximumPacketSize,
+  ],
+  [PropertySetType.connack]: [
+    propertyToId.sessionExpiryInterval,
+    propertyToId.assignedClientIdentifier,
+    propertyToId.serverKeepAlive,
+    propertyToId.authenticationMethod,
+    propertyToId.authenticationData,
+    propertyToId.responseInformation,
+    propertyToId.serverReference,
+    propertyToId.reasonString,
+    propertyToId.receiveMaximum,
+    propertyToId.topicAliasMaximum,
+    propertyToId.maximumQos,
+    propertyToId.retainAvailable,
+    propertyToId.userProperty,
+    propertyToId.maximumPacketSize,
+    propertyToId.wildcardSubscriptionAvailable,
+    propertyToId.subscriptionIdentifierAvailable,
+    propertyToId.sharedSubscriptionAvailable,
+  ],
+  [PropertySetType.publish]: [
+    propertyToId.payloadFormatIndicator,
+    propertyToId.messageExpiryInterval,
+    propertyToId.contentType,
+    propertyToId.responseTopic,
+    propertyToId.correlationData,
+    propertyToId.subscriptionIdentifiers,
+    propertyToId.topicAlias,
+    propertyToId.userProperty,
+  ],
+  [PropertySetType.subscribe]: [
+    propertyToId.subscriptionIdentifier,
+    propertyToId.userProperty,
+  ],
+  [PropertySetType.unsubscribe]: [
+    propertyToId.userProperty,
+  ],
+
+  [PropertySetType.disconnect]: [
+    propertyToId.sessionExpiryInterval,
+    propertyToId.serverReference,
+    propertyToId.reasonString,
+    propertyToId.userProperty,
+  ],
+  [PropertySetType.auth]: [
+    propertyToId.authenticationMethod,
+    propertyToId.authenticationData,
+    propertyToId.reasonString,
+    propertyToId.userProperty,
+  ],
+  [PropertySetType.puback]: [
+    propertyToId.reasonString,
+    propertyToId.userProperty,
+  ],
+  [PropertySetType.pubrec]: [
+    propertyToId.reasonString,
+    propertyToId.userProperty,
+  ],
+  [PropertySetType.pubrel]: [
+    propertyToId.reasonString,
+    propertyToId.userProperty,
+  ],
+  [PropertySetType.pubcomp]: [
+    propertyToId.reasonString,
+    propertyToId.userProperty,
+  ],
+  [PropertySetType.suback]: [
+    propertyToId.reasonString,
+    propertyToId.userProperty,
+  ],
+  [PropertySetType.unsuback]: [
+    propertyToId.reasonString,
+    propertyToId.userProperty,
+  ],
+  [PropertySetType.pingreq]: [],
+  [PropertySetType.pingres]: [],
+
+  [PropertySetType.will]: [
+    propertyToId.payloadFormatIndicator,
+    propertyToId.messageExpiryInterval,
+    propertyToId.contentType,
+    propertyToId.responseTopic,
+    propertyToId.correlationData,
+    propertyToId.willDelayInterval,
+    propertyToId.userProperty,
+  ],
+} as const;
+
+// helper types
+type PropertyIdsToKeys<T extends readonly ValidPropertyNumber[]> = {
+  [K in T[number]]: (typeof propertyByNumber)[K];
+}[T[number]];
+
+// from AllMqttv5Properties pick the ones returned by PropertyIdsToKeys for this type
+type GeneratePacketTypeProperties<T extends readonly ValidPropertyNumber[]> =
+  Pick<AllMqttv5Properties, PropertyIdsToKeys<T>>;
+
+export type PropsByPacketSetType = {
+  [K in TPropertySetType]: GeneratePacketTypeProperties<
+    typeof PropertyByPropertySetType[K]
+  >;
+};
+
+// props per PacketType
+export type ConnectProperties =
+  PropsByPacketSetType[typeof PropertySetType.connect];
+export type ConnackProperties =
+  PropsByPacketSetType[typeof PropertySetType.connack];
+export type PublishProperties =
+  PropsByPacketSetType[typeof PropertySetType.publish];
+export type PubackProperties =
+  PropsByPacketSetType[typeof PropertySetType.puback];
+export type PubrecProperties =
+  PropsByPacketSetType[typeof PropertySetType.pubrec];
+export type PubrelProperties =
+  PropsByPacketSetType[typeof PropertySetType.pubrel];
+export type PubcompProperties =
+  PropsByPacketSetType[typeof PropertySetType.pubcomp];
+export type SubscribeProperties =
+  PropsByPacketSetType[typeof PropertySetType.subscribe];
+export type SubackProperties =
+  PropsByPacketSetType[typeof PropertySetType.suback];
+export type UnsubscribeProperties =
+  PropsByPacketSetType[typeof PropertySetType.unsubscribe];
+export type UnsubackProperties =
+  PropsByPacketSetType[typeof PropertySetType.unsuback];
+export type DisconnectProperties =
+  PropsByPacketSetType[typeof PropertySetType.disconnect];
+export type AuthProperties = PropsByPacketSetType[typeof PropertySetType.auth];
+export type WillProperties = PropsByPacketSetType[typeof PropertySetType.will];

package/mqttPacket/ReasonCode.test.ts

@@ -0,0 +1,22 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { ReasonCode, reasonCodeToString } from "./ReasonCode.ts";
+import { PacketType } from "./mod.ts";
+
+test("lookup of reason codes works", () => {
+  assert.equal(
+    reasonCodeToString(PacketType.connect, ReasonCode.success),
+    "Success",
+    "Succes on Connect works",
+  );
+  assert.equal(
+    reasonCodeToString(PacketType.suback, ReasonCode.success),
+    "Granted QoS 0",
+    "Granted QoS 0 on Suback works",
+  );
+  assert.equal(
+    reasonCodeToString(PacketType.disconnect, ReasonCode.success),
+    "Normal disconnection",
+    "Normal disconnection on Disconnect works",
+  );
+});

package/mqttPacket/ReasonCode.ts

@@ -0,0 +1,256 @@
+/**
+ *  Possible MQTT V5 reason codes
+ */
+
+import { PacketType } from "./PacketType.ts";
+import type { InvertRecord } from "./types.ts";
+
+export const ReasonCode = {
+  success: 0x00,
+  normalDisconnection: 0x00,
+  grantedQos0: 0x00,
+  grantedQos1: 0x01,
+  grantedQos2: 0x02,
+  disconnectWithWillMessage: 0x04,
+  noMatchingSubscribers: 0x10,
+  noSubscriptionExisted: 0x11,
+  continueAuthentication: 0x18,
+  reAuthenticate: 0x19,
+  unspecifiedError: 0x80,
+  malformedPacket: 0x81,
+  protocolError: 0x82,
+  implementationSpecificError: 0x83,
+  unsupportedProtocolVersion: 0x84,
+  clientIdentifierNotValid: 0x85,
+  badUserNameOrPassword: 0x86,
+  notAuthorized: 0x87,
+  serverUnavailable: 0x88,
+  serverBusy: 0x89,
+  banned: 0x8a,
+  serverShuttingDown: 0x8b,
+  badAuthenticationMethod: 0x8c,
+  keepAliveTimeout: 0x8d,
+  sessionTakenOver: 0x8e,
+  topicFilterInvalid: 0x8f,
+  topicNameInvalid: 0x90,
+  packetIdentifierInUse: 0x91,
+  packetIdentifierNotFound: 0x92,
+  receiveMaximumExceeded: 0x93,
+  topicAliasInvalid: 0x94,
+  packetTooLarge: 0x95,
+  messageRateTooHigh: 0x96,
+  quotaExceeded: 0x97,
+  administrativeAction: 0x98,
+  payloadFormatInvalid: 0x99,
+  retainNotSupported: 0x9a,
+  qosNotSupported: 0x9b,
+  useAnotherServer: 0x9c,
+  serverMoved: 0x9d,
+  sharedSubscriptionsNotSupported: 0x9e,
+  connectionRateExceeded: 0x9f,
+  maximumConnectTime: 0xa0,
+  subscriptionIdentifiersNotSupported: 0xa1,
+  wildcardSubscriptionsNotSupported: 0xa2,
+} as const;
+
+/**
+ * Reverse lookup for ReasonCode
+ */
+
+export type ReasonCodeByNumberType = InvertRecord<typeof ReasonCode>;
+export const ReasonCodeByNumber = Object
+  .fromEntries(
+    Object.entries(ReasonCode).map(([k, v]) => [v, k]),
+  ) as ReasonCodeByNumberType;
+
+export const ReasonCodebyPacket = {
+  [PacketType.connack]: [
+    ReasonCode.success,
+    ReasonCode.unspecifiedError,
+    ReasonCode.malformedPacket,
+    ReasonCode.protocolError,
+    ReasonCode.implementationSpecificError,
+    ReasonCode.unsupportedProtocolVersion,
+    ReasonCode.clientIdentifierNotValid,
+    ReasonCode.badUserNameOrPassword,
+    ReasonCode.notAuthorized,
+    ReasonCode.serverUnavailable,
+    ReasonCode.serverBusy,
+    ReasonCode.banned,
+    ReasonCode.badAuthenticationMethod,
+    ReasonCode.topicNameInvalid,
+    ReasonCode.packetTooLarge,
+    ReasonCode.quotaExceeded,
+    ReasonCode.payloadFormatInvalid,
+    ReasonCode.retainNotSupported,
+    ReasonCode.qosNotSupported,
+    ReasonCode.useAnotherServer,
+    ReasonCode.serverMoved,
+    ReasonCode.connectionRateExceeded,
+  ],
+  [PacketType.puback]: [
+    ReasonCode.success,
+    ReasonCode.noMatchingSubscribers,
+    ReasonCode.unspecifiedError,
+    ReasonCode.implementationSpecificError,
+    ReasonCode.notAuthorized,
+    ReasonCode.topicNameInvalid,
+    ReasonCode.packetIdentifierInUse,
+    ReasonCode.quotaExceeded,
+    ReasonCode.payloadFormatInvalid,
+  ],
+  [PacketType.pubrec]: [
+    ReasonCode.success,
+    ReasonCode.noMatchingSubscribers,
+    ReasonCode.unspecifiedError,
+    ReasonCode.implementationSpecificError,
+    ReasonCode.notAuthorized,
+    ReasonCode.topicNameInvalid,
+    ReasonCode.packetIdentifierInUse,
+    ReasonCode.quotaExceeded,
+    ReasonCode.payloadFormatInvalid,
+  ],
+  [PacketType.pubrel]: [
+    ReasonCode.success,
+    ReasonCode.packetIdentifierNotFound,
+  ],
+  [PacketType.pubcomp]: [
+    ReasonCode.success,
+    ReasonCode.packetIdentifierNotFound,
+  ],
+  [PacketType.unsuback]: [
+    ReasonCode.success,
+    ReasonCode.noSubscriptionExisted,
+    ReasonCode.unspecifiedError,
+    ReasonCode.implementationSpecificError,
+    ReasonCode.notAuthorized,
+    ReasonCode.topicFilterInvalid,
+    ReasonCode.packetIdentifierInUse,
+  ],
+  [PacketType.auth]: [
+    ReasonCode.success,
+    ReasonCode.continueAuthentication,
+    ReasonCode.reAuthenticate,
+  ],
+  [PacketType.disconnect]: [
+    ReasonCode.normalDisconnection,
+    ReasonCode.disconnectWithWillMessage,
+    ReasonCode.unspecifiedError,
+    ReasonCode.malformedPacket,
+    ReasonCode.protocolError,
+    ReasonCode.implementationSpecificError,
+    ReasonCode.notAuthorized,
+    ReasonCode.serverBusy,
+    ReasonCode.serverShuttingDown,
+    ReasonCode.badAuthenticationMethod,
+    ReasonCode.keepAliveTimeout,
+    ReasonCode.sessionTakenOver,
+    ReasonCode.topicFilterInvalid,
+    ReasonCode.topicNameInvalid,
+    ReasonCode.receiveMaximumExceeded,
+    ReasonCode.topicAliasInvalid,
+    ReasonCode.packetTooLarge,
+    ReasonCode.messageRateTooHigh,
+    ReasonCode.quotaExceeded,
+    ReasonCode.administrativeAction,
+    ReasonCode.payloadFormatInvalid,
+    ReasonCode.retainNotSupported,
+    ReasonCode.qosNotSupported,
+    ReasonCode.useAnotherServer,
+    ReasonCode.serverMoved,
+    ReasonCode.sharedSubscriptionsNotSupported,
+    ReasonCode.connectionRateExceeded,
+    ReasonCode.maximumConnectTime,
+    ReasonCode.subscriptionIdentifiersNotSupported,
+    ReasonCode.wildcardSubscriptionsNotSupported,
+  ],
+  [PacketType.suback]: [
+    ReasonCode.grantedQos0,
+    ReasonCode.grantedQos1,
+    ReasonCode.grantedQos2,
+    ReasonCode.unspecifiedError,
+    ReasonCode.implementationSpecificError,
+    ReasonCode.notAuthorized,
+    ReasonCode.topicFilterInvalid,
+    ReasonCode.packetIdentifierInUse,
+    ReasonCode.quotaExceeded,
+    ReasonCode.sharedSubscriptionsNotSupported,
+    ReasonCode.subscriptionIdentifiersNotSupported,
+    ReasonCode.wildcardSubscriptionsNotSupported,
+  ],
+} as const;
+
+const reasonCodesToString = {
+  [0x00]: "Success",
+  [0x01]: "Granted QoS 1",
+  [0x02]: "Granted QoS 2",
+  [0x04]: "Disconnect with Will Message",
+  [0x10]: "No matching subscribers",
+  [0x11]: "No subscription existed",
+  [0x18]: "Continue authentication",
+  [0x19]: "Re-authenticate",
+  [0x80]: "Unspecified error",
+  [0x81]: "Malformed Packet",
+  [0x82]: "Protocol Error",
+  [0x83]: "Implementation specific error",
+  [0x84]: "Unsupported Protocol Version",
+  [0x85]: "Client Identifier not valid",
+  [0x86]: "Bad User Name or Password",
+  [0x87]: "Not authorized",
+  [0x88]: "Server unavailable",
+  [0x89]: "Server busy",
+  [0x8a]: "Banned",
+  [0x8b]: "Server shutting down",
+  [0x8c]: "Bad authentication method",
+  [0x8d]: "Keep Alive timeout",
+  [0x8e]: "Session taken over",
+  [0x8f]: "Topic Filter invalid",
+  [0x90]: "Topic Name invalid",
+  [0x91]: "Packet Identifier in use",
+  [0x92]: "Packet Identifier not found",
+  [0x93]: "Receive Maximum exceeded",
+  [0x94]: "Topic Alias invalid",
+  [0x95]: "Packet too large",
+  [0x96]: "Message rate too high",
+  [0x97]: "Quota exceeded",
+  [0x98]: "Administrative action",
+  [0x99]: "Payload format invalid",
+  [0x9a]: "Retain not supported",
+  [0x9b]: "QoS not supported",
+  [0x9c]: "Use another server",
+  [0x9d]: "Server moved",
+  [0x9e]: "Shared Subscriptions not supported",
+  [0x9f]: "Connection rate exceeded",
+  [0xa0]: "Maximum connect time",
+  [0xa1]: "Subscription Identifiers not supported",
+  [0xa2]: "Wildcard Subscriptions not supported",
+} as const;
+
+// Can't import this from types as this would create an import loop
+type TPacketType = typeof PacketType[keyof typeof PacketType];
+export type TReasonCode = typeof ReasonCode[keyof typeof ReasonCode];
+type TReasonCodeByPacket = keyof typeof ReasonCodebyPacket;
+
+export function reasonCodeToString(
+  packetType: TPacketType,
+  code: TReasonCode,
+): string {
+  if (code === 0) {
+    if (packetType === PacketType.disconnect) {
+      return "Normal disconnection";
+    }
+    if (packetType === PacketType.suback) {
+      return "Granted QoS 0";
+    }
+  }
+  return reasonCodesToString[code];
+}
+
+export function isValidReasonCode(
+  packetType: TPacketType,
+  code: number,
+): boolean {
+  const validReasonCodes =
+    ReasonCodebyPacket[packetType as TReasonCodeByPacket] as readonly number[];
+  return validReasonCodes.includes(code);
+}