@seriousme/opifex 1.11.2 → 2.0.3

package/client/handlers/handleConnack.test.ts

@@ -0,0 +1,173 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { handleConnack } from "./handleConnack.ts";
+import { ConnectionState } from "../ConnectionState.ts";
+import { AuthenticationResult, MQTTLevel } from "../deps.ts";
+import type { ConnackPacket } from "../deps.ts";
+import { Deferred } from "../../utils/mod.ts";
+
+function createMockContext() {
+  const sentPackets: unknown[] = [];
+  return {
+    connectionState: ConnectionState.connecting as string,
+    protocolLevel: 4 as const,
+    mqttConn: { codecOpts: { protocolLevel: MQTTLevel.unknown } },
+    pingTimer: { reset: () => {}, clear: () => {} },
+    unresolvedConnect: new Deferred<number>(),
+    store: {
+      pendingOutgoing: new Map(),
+      pendingIncoming: new Map(),
+      pendingAckOutgoing: new Map(),
+      async *pendingOutgoingPackets() {},
+    },
+    send: (packet: unknown) => {
+      sentPackets.push(packet);
+    },
+    sentPackets,
+  };
+}
+
+test("handleConnack sets connected state on success", async () => {
+  const ctx = createMockContext();
+  const packet = {
+    type: 2,
+    protocolLevel: 4 as const,
+    sessionPresent: false,
+    returnCode: AuthenticationResult.ok,
+  } as ConnackPacket;
+
+  await handleConnack(ctx as never, packet);
+
+  assert.deepStrictEqual(
+    ctx.connectionState,
+    ConnectionState.connected,
+    "Should be connected after successful CONNACK",
+  );
+});
+
+test("handleConnack resolves connect promise on success", async () => {
+  const ctx = createMockContext();
+  const packet = {
+    type: 2,
+    protocolLevel: 4 as const,
+    sessionPresent: false,
+    returnCode: AuthenticationResult.ok,
+  } as ConnackPacket;
+
+  await handleConnack(ctx as never, packet);
+
+  const result = await ctx.unresolvedConnect.promise;
+  assert.deepStrictEqual(result, 0, "Should resolve with success code 0");
+});
+
+test("handleConnack rejects on bad username/password", async () => {
+  const ctx = createMockContext();
+  const packet = {
+    type: 2,
+    protocolLevel: 4 as const,
+    sessionPresent: false,
+    returnCode: AuthenticationResult.badUsernameOrPassword,
+  } as ConnackPacket;
+
+  await handleConnack(ctx as never, packet);
+
+  assert.deepStrictEqual(
+    ctx.connectionState,
+    ConnectionState.disconnecting,
+    "Should be disconnecting on auth failure",
+  );
+
+  await assert.rejects(
+    ctx.unresolvedConnect.promise,
+    /Connect failed/,
+    "Should reject with connect failed error",
+  );
+});
+
+test("handleConnack rejects on not authorized", async () => {
+  const ctx = createMockContext();
+  const packet = {
+    type: 2,
+    protocolLevel: 4 as const,
+    sessionPresent: false,
+    returnCode: AuthenticationResult.notAuthorized,
+  } as ConnackPacket;
+
+  await handleConnack(ctx as never, packet);
+
+  assert.deepStrictEqual(
+    ctx.connectionState,
+    ConnectionState.disconnecting,
+  );
+
+  await assert.rejects(
+    ctx.unresolvedConnect.promise,
+    /Connect failed/,
+  );
+});
+
+test("handleConnack handles MQTT v5 reason codes", async () => {
+  const ctx = createMockContext();
+  (ctx as { protocolLevel: number }).protocolLevel = 5;
+  const packet = {
+    type: 2,
+    protocolLevel: 5 as const,
+    sessionPresent: false,
+    reasonCode: 0,
+  } as ConnackPacket;
+
+  await handleConnack(ctx as never, packet);
+
+  assert.deepStrictEqual(
+    ctx.connectionState,
+    ConnectionState.connected,
+    "Should be connected with v5 success reason code",
+  );
+});
+
+test("handleConnack resets ping timer on success", async () => {
+  let timerReset = false;
+  const ctx = createMockContext();
+  ctx.pingTimer = {
+    reset: () => {
+      timerReset = true;
+    },
+    clear: () => {},
+  };
+
+  const packet = {
+    type: 2,
+    protocolLevel: 4 as const,
+    sessionPresent: false,
+    returnCode: AuthenticationResult.ok,
+  } as ConnackPacket;
+
+  await handleConnack(ctx as never, packet);
+
+  assert.deepStrictEqual(timerReset, true, "Ping timer should be reset");
+});
+
+test("handleConnack clears ping timer on failure", async () => {
+  let timerCleared = false;
+  const ctx = createMockContext();
+  ctx.pingTimer = {
+    reset: () => {},
+    clear: () => {
+      timerCleared = true;
+    },
+  };
+
+  const packet = {
+    type: 2,
+    protocolLevel: 4 as const,
+    sessionPresent: false,
+    returnCode: AuthenticationResult.badUsernameOrPassword,
+  } as ConnackPacket;
+
+  await handleConnack(ctx as never, packet);
+  assert.deepStrictEqual(timerCleared, true, "Ping timer should be cleared");
+  await assert.rejects(
+    ctx.unresolvedConnect.promise,
+    /Connect failed/,
+  );
+});

package/client/handlers/handleConnack.ts

@@ -5,20 +5,30 @@ import type { ConnackPacket, TReasonCode } from "../deps.ts";
 
 /**
  * Handles the CONNACK packet received from the MQTT broker
- * @param packet - The CONNACK packet containing the connection acknowledgment
  * @param ctx - The connection context
+ * @param packet - The CONNACK packet containing the connection acknowledgment
  * @returns Promise that resolves when handling is complete
  */
-export async function handleConnack(packet: ConnackPacket, ctx: Context) {
-  const result = packet.protocolLevel === 5
-    ? packet.reasonCode
-    : packet.returnCode;
+export async function handleConnack(ctx: Context, packet: ConnackPacket) {
+  const isVersion5 = packet.protocolLevel === 5;
+  const result = isVersion5 ? packet.reasonCode : packet.returnCode;
   if (result === 0) {
     ctx.connectionState = ConnectionState.connected;
     if (ctx.mqttConn) {
       ctx.mqttConn.codecOpts.protocolLevel = ctx.protocolLevel;
     }
-    ctx.pingTimer?.reset();
+
+    const serverKeepAlive = isVersion5
+      ? packet.properties?.serverKeepAlive
+      : undefined;
+
+    if (serverKeepAlive === 0) {
+      ctx.pingTimer?.clear(); // Server disabled keepalive
+    } else if (serverKeepAlive !== undefined) {
+      ctx.setPingTimer(serverKeepAlive); // Server set a new interval
+    } else {
+      ctx.pingTimer?.reset(); // Default fallback for V4 or V5 without override
+    }
     ctx.unresolvedConnect?.resolve(result);
     // start transmitting packets that were queued before
     for await (const packet of ctx.store.pendingOutgoingPackets()) {

package/client/handlers/handleDisconnect.test.ts

@@ -0,0 +1,22 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { handleDisconnect } from "./handleDisconnect.ts";
+import { PacketType, ReasonCode, ReasonCodeByNumber } from "../deps.ts";
+import type { DisconnectPacket } from "../deps.ts";
+
+function createMockContext() {
+  return {
+    close: () => {},
+  };
+}
+
+test("handleDisconnect processes V5 rejection", () => {
+  const ctx = createMockContext();
+  const reasonCode = ReasonCode.notAuthorized;
+  assert.throws(() =>
+    handleDisconnect(ctx as never, {
+      type: PacketType.disconnect,
+      protocolLevel: 5,
+      reasonCode,
+    } as DisconnectPacket), Error(ReasonCodeByNumber[reasonCode]));
+});

package/client/handlers/handleDisconnect.ts

@@ -0,0 +1,17 @@
+import type { Context } from "../context.ts";
+import type { DisconnectPacket } from "../deps.ts";
+import { ReasonCodeByNumber } from "../deps.ts";
+
+/**
+ * Handles Disconnect Packet sent by the broker (V5 only)
+ * @param ctx - The MQTT client context
+ * @param packet - The PUBACK packet received from the broker
+ * @description
+ * - throw error
+ */
+export function handleDisconnect(ctx: Context, packet: DisconnectPacket): void {
+  if (packet.protocolLevel === 5 && ((packet.reasonCode ?? 0) !== 0)) {
+    throw new Error(ReasonCodeByNumber[packet.reasonCode!]);
+  }
+  ctx.close();
+}

package/client/handlers/handlePacket.test.ts

@@ -0,0 +1,242 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { handlePacket } from "./handlePacket.ts";
+import { ConnectionState } from "../ConnectionState.ts";
+import { AuthenticationResult, MQTTLevel, PacketType } from "../deps.ts";
+import type { AnyPacket, PublishPacket } from "../deps.ts";
+import { Deferred } from "../../utils/mod.ts";
+
+function createMockContext() {
+  const sentPackets: unknown[] = [];
+  const receivedPublishes: PublishPacket[] = [];
+  const receivedIds: {
+    puback: number[];
+    pubcomp: number[];
+    suback: number[];
+    unsuback: number[];
+  } = {
+    puback: [],
+    pubcomp: [],
+    suback: [],
+    unsuback: [],
+  };
+  return {
+    connectionState: ConnectionState.connecting as string,
+    protocolLevel: 4 as const,
+    mqttConn: { codecOpts: { protocolLevel: MQTTLevel.unknown } },
+    pingTimer: { reset: () => {}, clear: () => {} },
+    unresolvedConnect: new Deferred<number>(),
+    store: {
+      pendingOutgoing: new Map<number, unknown>(),
+      pendingIncoming: new Map<number, PublishPacket>(),
+      pendingAckOutgoing: new Map<number, unknown>(),
+      async *pendingOutgoingPackets() {},
+    },
+    send: (packet: unknown) => {
+      sentPackets.push(packet);
+    },
+    receivePublish: (packet: PublishPacket) => {
+      receivedPublishes.push(packet);
+    },
+    receivePuback: (id: number) => {
+      receivedIds.puback.push(id);
+      return true;
+    },
+    receivePubcomp: (id: number) => {
+      receivedIds.pubcomp.push(id);
+      return true;
+    },
+    receiveSuback: (id: number, _codes: number[]) => {
+      receivedIds.suback.push(id);
+      return true;
+    },
+    receiveUnsuback: (id: number) => {
+      receivedIds.unsuback.push(id);
+      return true;
+    },
+    sentPackets,
+    receivedPublishes,
+    receivedIds,
+  };
+}
+
+test("handlePacket dispatches CONNACK before connected", async () => {
+  const ctx = createMockContext();
+
+  const packet = {
+    type: PacketType.connack,
+    protocolLevel: 4 as const,
+    sessionPresent: false,
+    returnCode: AuthenticationResult.ok,
+  } as AnyPacket;
+
+  await handlePacket(ctx as never, packet);
+
+  assert.deepStrictEqual(
+    ctx.connectionState,
+    ConnectionState.connected,
+    "Should handle CONNACK and set connected state",
+  );
+});
+
+test("handlePacket rejects non-CONNACK before connected", async () => {
+  const ctx = createMockContext();
+
+  const packet = {
+    type: PacketType.pingreq,
+    protocolLevel: 4,
+  } as AnyPacket;
+
+  await assert.rejects(
+    handlePacket(ctx as never, packet),
+    /while connecting/,
+    "Should reject packets before CONNACK",
+  );
+});
+
+test("handlePacket dispatches PUBLISH after connected", async () => {
+  const ctx = createMockContext();
+  ctx.connectionState = ConnectionState.connected;
+
+  const packet = {
+    type: PacketType.publish,
+    protocolLevel: 4 as const,
+    topic: "test/topic",
+    payload: new Uint8Array([1, 2, 3]),
+    qos: 0 as const,
+    retain: false,
+    dup: false,
+  } as AnyPacket;
+
+  await handlePacket(ctx as never, packet);
+
+  assert.deepStrictEqual(
+    ctx.receivedPublishes.length,
+    1,
+    "Should dispatch PUBLISH to handler",
+  );
+});
+
+test("handlePacket dispatches PUBACK after connected", async () => {
+  const ctx = createMockContext();
+  ctx.connectionState = ConnectionState.connected;
+
+  const packet = {
+    type: PacketType.puback,
+    protocolLevel: 4 as const,
+    id: 1,
+  } as AnyPacket;
+
+  await handlePacket(ctx as never, packet);
+
+  assert.deepStrictEqual(
+    ctx.receivedIds.puback,
+    [1],
+    "Should dispatch PUBACK to handler",
+  );
+});
+
+test("handlePacket dispatches PINGRES silently", async () => {
+  const ctx = createMockContext();
+  ctx.connectionState = ConnectionState.connected;
+
+  const packet = {
+    type: PacketType.pingres,
+    protocolLevel: 4,
+  } as AnyPacket;
+
+  // Should not throw
+  await handlePacket(ctx as never, packet);
+
+  // PINGRES is silently handled (no specific action)
+  assert.deepStrictEqual(ctx.sentPackets.length, 0);
+});
+
+test("handlePacket dispatches SUBACK after connected", async () => {
+  const ctx = createMockContext();
+  ctx.connectionState = ConnectionState.connected;
+  ctx.store.pendingOutgoing.set(1, { type: PacketType.subscribe });
+
+  const packet = {
+    type: PacketType.suback,
+    protocolLevel: 4 as const,
+    id: 1,
+    returnCodes: [0],
+  } as AnyPacket;
+
+  await handlePacket(ctx as never, packet);
+
+  assert.deepStrictEqual(
+    ctx.receivedIds.suback,
+    [1],
+    "Should dispatch SUBACK to handler",
+  );
+});
+
+test("handlePacket dispatches UNSUBACK after connected", async () => {
+  const ctx = createMockContext();
+  ctx.connectionState = ConnectionState.connected;
+  ctx.store.pendingOutgoing.set(2, { type: PacketType.unsubscribe });
+
+  const packet = {
+    type: PacketType.unsuback,
+    protocolLevel: 4 as const,
+    id: 2,
+  } as AnyPacket;
+
+  await handlePacket(ctx as never, packet);
+
+  assert.deepStrictEqual(
+    ctx.receivedIds.unsuback,
+    [2],
+    "Should dispatch UNSUBACK to handler",
+  );
+});
+
+test("handlePacket rejects unexpected packet types", async () => {
+  const ctx = createMockContext();
+  ctx.connectionState = ConnectionState.connected;
+
+  // CONNECT shouldn't be received by client after connection
+  const packet = {
+    type: PacketType.connect,
+    protocolName: "MQTT",
+    protocolLevel: 4 as const,
+    clientId: "test",
+    clean: true,
+    keepAlive: 0,
+  } as AnyPacket;
+
+  await assert.rejects(
+    handlePacket(ctx as never, packet),
+    /unexpected/i,
+    "Should reject unexpected packet types",
+  );
+});
+
+test("handlePacket handles QoS 2 flow packets", async () => {
+  const ctx = createMockContext();
+  ctx.connectionState = ConnectionState.connected;
+
+  // Test PUBREC
+  ctx.store.pendingOutgoing.set(10, { type: PacketType.publish, id: 10 });
+  await handlePacket(ctx as never, {
+    type: PacketType.pubrec,
+    protocolLevel: 4,
+    id: 10,
+  } as AnyPacket);
+  assert.deepStrictEqual(ctx.sentPackets.length, 1);
+  assert.deepStrictEqual(
+    (ctx.sentPackets[0] as { type: number }).type,
+    PacketType.pubrel,
+  );
+
+  // Test PUBCOMP
+  ctx.store.pendingAckOutgoing.set(10, { type: PacketType.pubrel, id: 10 });
+  await handlePacket(ctx as never, {
+    type: PacketType.pubcomp,
+    protocolLevel: 4,
+    id: 10,
+  } as AnyPacket);
+  assert.deepStrictEqual(ctx.receivedIds.pubcomp, [10]);
+});

package/client/handlers/handlePacket.ts

@@ -1,5 +1,6 @@
 import type { Context } from "../context.ts";
 import { ConnectionState } from "../ConnectionState.ts";
+import { handleAuth } from "./handleAuth.ts";
 import { handleConnack } from "./handleConnack.ts";
 import { handlePublish } from "./handlePublish.ts";
 import { handlePuback } from "./handlePuback.ts";
@@ -8,10 +9,13 @@ import { handlePubrel } from "./handlePubrel.ts";
 import { handlePubcomp } from "./handlePubcomp.ts";
 import { handleSuback } from "./handleSuback.ts";
 import { handleUnsuback } from "./handleUnsuback.ts";
+import { handleDisconnect } from "./handleDisconnect.ts";
 import { logger, PacketNameByType, PacketType } from "../deps.ts";
 import type {
   AnyPacket,
+  AuthPacket,
   ConnackPacket,
+  DisconnectPacket,
   PubackPacket,
   PubcompPacket,
   PublishPacket,
@@ -35,14 +39,21 @@ export async function handlePacket(
   logger.debug({ received: PacketNameByType[packet.type], packet });
   if (ctx.connectionState !== ConnectionState.connected) {
     if (packet.type === PacketType.connack) {
-      handleConnack(packet as ConnackPacket, ctx);
-    } else {
-      throw new Error(
-        `Received ${PacketNameByType[packet.type]} packet before connect`,
-      );
+      handleConnack(ctx, packet as ConnackPacket);
+      return;
     }
+    if (packet.type === PacketType.auth) {
+      await handleAuth(ctx, packet as AuthPacket);
+      return;
+    }
+    throw new Error(
+      `Received ${PacketNameByType[packet.type]} packet while connecting`,
+    );
   } else {
     switch (packet.type) {
+      case PacketType.auth:
+        await handleAuth(ctx, packet as AuthPacket);
+        break;
       case PacketType.pingres:
         break;
       case PacketType.publish:
@@ -66,6 +77,9 @@ export async function handlePacket(
       case PacketType.unsuback:
         handleUnsuback(ctx, packet as UnsubackPacket);
         break;
+      case PacketType.disconnect:
+        handleDisconnect(ctx, packet as DisconnectPacket);
+        break;
 
       default:
         throw new Error(

package/client/handlers/handlePuback.test.ts

@@ -0,0 +1,99 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { handlePuback } from "./handlePuback.ts";
+import { PacketType, ReasonCode, ReasonCodeByNumber } from "../deps.ts";
+import type { PubackPacket } from "../deps.ts";
+
+function createMockContext() {
+  const receivedIds: number[] = [];
+  return {
+    protocolLevel: 4 as const,
+    store: {
+      pendingOutgoing: new Map<number, unknown>(),
+      pendingIncoming: new Map(),
+      pendingAckOutgoing: new Map(),
+    },
+    receivePuback: (id: number) => {
+      receivedIds.push(id);
+      return true;
+    },
+    receivedIds,
+  };
+}
+
+test("handlePuback removes packet from pending and notifies context", () => {
+  const ctx = createMockContext();
+  ctx.store.pendingOutgoing.set(1, { type: PacketType.publish });
+
+  const packet = {
+    type: PacketType.puback,
+    protocolLevel: 4 as const,
+    id: 1,
+  } as PubackPacket;
+
+  handlePuback(ctx as never, packet);
+
+  assert.deepStrictEqual(
+    ctx.store.pendingOutgoing.has(1),
+    false,
+    "Should remove from pending",
+  );
+  assert.deepStrictEqual(
+    ctx.receivedIds,
+    [1],
+    "Should notify context of puback",
+  );
+});
+
+test("handlePuback handles non-existent packet ID gracefully", () => {
+  const ctx = createMockContext();
+
+  const packet = {
+    type: PacketType.puback,
+    protocolLevel: 4 as const,
+    id: 999,
+  } as PubackPacket;
+
+  // Should not throw
+  handlePuback(ctx as never, packet);
+
+  assert.deepStrictEqual(
+    ctx.receivedIds,
+    [999],
+    "Should still notify context",
+  );
+});
+
+test("handlePuback processes multiple PUBACKs correctly", () => {
+  const ctx = createMockContext();
+  ctx.store.pendingOutgoing.set(1, { type: PacketType.publish });
+  ctx.store.pendingOutgoing.set(2, { type: PacketType.publish });
+  ctx.store.pendingOutgoing.set(3, { type: PacketType.publish });
+
+  handlePuback(ctx as never, {
+    type: PacketType.puback,
+    protocolLevel: 4,
+    id: 2,
+  } as PubackPacket);
+
+  assert.deepStrictEqual(ctx.store.pendingOutgoing.has(1), true);
+  assert.deepStrictEqual(ctx.store.pendingOutgoing.has(2), false);
+  assert.deepStrictEqual(ctx.store.pendingOutgoing.has(3), true);
+  assert.deepStrictEqual(ctx.receivedIds, [2]);
+});
+
+test("handlePuback processes V5 publish rejection", () => {
+  const ctx = createMockContext();
+  const reasonCode = ReasonCode.notAuthorized;
+  ctx.store.pendingOutgoing.set(2, {
+    type: PacketType.publish,
+    topic: "Test Puback",
+  });
+  assert.throws(() =>
+    handlePuback(ctx as never, {
+      type: PacketType.puback,
+      protocolLevel: 5,
+      id: 2,
+      reasonCode,
+    } as PubackPacket), Error(ReasonCodeByNumber[reasonCode]));
+});

package/client/handlers/handlePuback.ts

@@ -1,5 +1,6 @@
 import type { Context } from "../context.ts";
 import type { PubackPacket } from "../deps.ts";
+import { ReasonCodeByNumber } from "../deps.ts";
 
 /**
  * Handles PUBACK packet processing for QoS level 1 PUBLISH responses
@@ -12,5 +13,10 @@ import type { PubackPacket } from "../deps.ts";
 export function handlePuback(ctx: Context, packet: PubackPacket): void {
   const id = packet.id;
   ctx.store.pendingOutgoing.delete(id);
+
+  if (packet.protocolLevel === 5 && ((packet.reasonCode ?? 0) !== 0)) {
+    ctx.store.pendingOutgoing.delete(id);
+    throw new Error(ReasonCodeByNumber[packet.reasonCode!]);
+  }
   ctx.receivePuback(id);
 }