@seriousme/opifex 1.11.3 → 2.1.0

package/persistence/memory/memoryStorage.ts

@@ -0,0 +1,232 @@
+/**
+ * @module
+ * Volatile in-memory implementation of StorageProvider.
+ * Completely decoupled from MQTT protocol logic.
+ */
+import type { ClientId, PacketId, Topic, TopicFilter } from "../deps.ts";
+import type {
+  ClientRegistrationResult,
+  ClientSubscription,
+  ExtPublishPacket,
+  ShareName,
+} from "../persistence.ts";
+import type { StorageProvider, StoredSubscription } from "../storage.ts";
+import { PacketDirection } from "../storage.ts";
+import { getOrInsert, joinTopicFilter, topicFilterToRegExp } from "../deps.ts";
+
+type pendingTableEntry = {
+  seqId: number;
+  packet: ExtPublishPacket;
+  createdAtMs: number;
+};
+
+export class MemoryStorage implements StorageProvider {
+  private seqId = 1;
+  private sessionTable = new Map<ClientId, ClientRegistrationResult>();
+
+  private subscriptionTable = new Map<
+    ClientId,
+    Map<TopicFilter, ClientSubscription>
+  >();
+
+  private pendingIncomingTable = new Map<
+    ClientId,
+    Map<PacketId, pendingTableEntry>
+  >();
+
+  private pendingOutgoingTable = new Map<
+    ClientId,
+    Map<PacketId, pendingTableEntry>
+  >();
+
+  private pendingAckOutgoingTable = new Map<ClientId, Set<PacketId>>();
+
+  private retainedTable = new Map<Topic, ExtPublishPacket>();
+
+  initialize(): Promise<void> {
+    return Promise.resolve();
+  }
+
+  // --- Sessions ---
+  saveSession(
+    clientId: ClientId,
+    session: ClientRegistrationResult,
+  ): Promise<void> {
+    this.sessionTable.set(clientId, session);
+    return Promise.resolve();
+  }
+
+  getSession(clientId: ClientId): Promise<ClientRegistrationResult | null> {
+    return Promise.resolve(this.sessionTable.get(clientId) ?? null);
+  }
+
+  deleteSession(clientId: ClientId): Promise<void> {
+    this.sessionTable.delete(clientId);
+    this.pendingIncomingTable.delete(clientId);
+    this.pendingOutgoingTable.delete(clientId);
+    this.pendingAckOutgoingTable.delete(clientId);
+    this.subscriptionTable.delete(clientId);
+    return Promise.resolve();
+  }
+
+  async *listAllSessions(): AsyncIterableIterator<
+    { clientId: ClientId; session: ClientRegistrationResult }
+  > {
+    for (const [clientId, session] of this.sessionTable.entries()) {
+      yield { clientId, session };
+    }
+  }
+
+  // --- Subscriptions ---
+  saveSubscription(clientId: ClientId, sub: ClientSubscription): Promise<void> {
+    const key = joinTopicFilter(sub.topicFilter, sub.shareName);
+    const clientSubs = getOrInsert(this.subscriptionTable, clientId, new Map());
+    clientSubs.set(key, sub);
+    return Promise.resolve();
+  }
+
+  deleteSubscription(
+    clientId: ClientId,
+    topicFilter: TopicFilter,
+    shareName: ShareName,
+  ): Promise<void> {
+    const key = joinTopicFilter(topicFilter, shareName);
+    this.subscriptionTable.get(clientId)?.delete(key);
+    return Promise.resolve();
+  }
+
+  async *listSubscriptions(
+    clientId: ClientId,
+  ): AsyncIterableIterator<ClientSubscription> {
+    const clientSubs = this.subscriptionTable.get(clientId);
+    if (clientSubs) {
+      for (const sub of clientSubs.values()) {
+        yield sub;
+      }
+    }
+  }
+
+  async *listAllSubscriptions(): AsyncIterableIterator<StoredSubscription> {
+    for (const [clientId, clientSubs] of this.subscriptionTable.entries()) {
+      for (const sub of clientSubs.values()) {
+        yield { ...sub, clientId };
+      }
+    }
+  }
+
+  // --- Pending Packets (Incoming & Outgoing) ---
+  private getPacketTable(clientId: ClientId, direction: PacketDirection) {
+    const table = direction === PacketDirection.Incoming
+      ? this.pendingIncomingTable
+      : this.pendingOutgoingTable;
+    return getOrInsert(table, clientId, new Map());
+  }
+
+  savePendingPacket(
+    clientId: ClientId,
+    direction: PacketDirection,
+    packet: ExtPublishPacket,
+  ): Promise<void> {
+    const createdAtMs = Date.now();
+    if (packet.id !== undefined) {
+      this.getPacketTable(clientId, direction).set(packet.id, {
+        seqId: this.seqId++,
+        packet,
+        createdAtMs,
+      });
+    }
+    return Promise.resolve();
+  }
+
+  getPendingPacket(
+    clientId: ClientId,
+    direction: PacketDirection,
+    packetId: PacketId,
+  ): Promise<ExtPublishPacket | null> {
+    const entry = this.getPacketTable(clientId, direction).get(packetId);
+    return Promise.resolve(entry?.packet ?? null);
+  }
+
+  updatePendingPacket(
+    clientId: ClientId,
+    direction: PacketDirection,
+    packetId: PacketId,
+    dup: boolean,
+  ): Promise<boolean> {
+    const entry = this.getPacketTable(clientId, direction).get(packetId);
+    if (entry !== undefined) {
+      entry.packet.dup = dup;
+    }
+    return Promise.resolve(entry !== undefined);
+  }
+
+  deletePendingPacket(
+    clientId: ClientId,
+    direction: PacketDirection,
+    packetId: PacketId,
+  ): Promise<boolean> {
+    const deleted = this.getPacketTable(clientId, direction).delete(packetId);
+    return Promise.resolve(deleted);
+  }
+
+  async *listPendingPackets(
+    clientId: ClientId,
+    direction: PacketDirection,
+  ): AsyncIterableIterator<ExtPublishPacket> {
+    const queue = this.getPacketTable(clientId, direction);
+    if (!queue) return;
+
+    for (const entry of queue.values()) {
+      yield entry.packet;
+    }
+  }
+
+  // --- ACKs ---
+  private getAckSet(clientId: ClientId): Set<PacketId> {
+    return getOrInsert(this.pendingAckOutgoingTable, clientId, new Set());
+  }
+
+  savePendingAck(clientId: ClientId, packetId: PacketId): Promise<void> {
+    this.getAckSet(clientId).add(packetId);
+    return Promise.resolve();
+  }
+
+  hasPendingAck(clientId: ClientId, packetId: PacketId): Promise<boolean> {
+    const hasAck = this.getAckSet(clientId).has(packetId);
+    return Promise.resolve(hasAck);
+  }
+
+  deletePendingAck(clientId: ClientId, packetId: PacketId): Promise<boolean> {
+    const deleted = this.getAckSet(clientId).delete(packetId);
+    return Promise.resolve(deleted);
+  }
+
+  async *listPendingAcks(clientId: ClientId): AsyncIterableIterator<PacketId> {
+    const ackSet = this.getAckSet(clientId);
+    for (const packetId of ackSet) {
+      yield packetId;
+    }
+  }
+
+  // --- Retained Messages ---
+  saveRetained(topic: Topic, packet: ExtPublishPacket): Promise<void> {
+    this.retainedTable.set(topic, packet);
+    return Promise.resolve();
+  }
+
+  deleteRetained(topic: Topic): Promise<void> {
+    this.retainedTable.delete(topic);
+    return Promise.resolve();
+  }
+
+  async *listRetainedMatches(
+    topicFilter: TopicFilter,
+  ): AsyncIterableIterator<ExtPublishPacket> {
+    const regex = topicFilterToRegExp(topicFilter);
+    for (const [topic, packet] of this.retainedTable.entries()) {
+      if (regex.test(topic)) {
+        yield packet;
+      }
+    }
+  }
+}

package/persistence/mod.ts

@@ -2,12 +2,7 @@
  * @module persistence
  * @description Module for handling MQTT message persistence and client management
  */
-export type {
-  IStore,
-  PacketIdStore,
-  PacketStore,
-  SubscriptionStore,
-} from "./store.ts";
+
 export type {
   ClientId,
   PacketId,
@@ -17,9 +12,9 @@ export type {
   TopicFilter,
 } from "./deps.ts";
 export type {
-  Client,
+  ClientRegistrationResult,
   Handler,
-  IPersistence,
-  RetainStore,
+  Persistence,
 } from "./persistence.ts";
-export { maxPacketId } from "./persistence.ts";
+export { MAX_PACKET_ID } from "./persistence.ts";
+export { SqlitePersistence } from "./sqlite/sqlitePersistence.ts";

package/persistence/persistence.test.ts

@@ -0,0 +1,24 @@
+import { MemoryPersistence } from "./memory/memoryPersistence.ts";
+import { SqlitePersistence } from "./sqlite/sqlitePersistence.ts";
+import { runPersistenceTestSuite } from "./persistence.testing.ts";
+
+// Run for Memory
+runPersistenceTestSuite({
+  name: "MemoryPersistence",
+  factory: () => ({
+    persistence: new MemoryPersistence(),
+    cleanup: () => {},
+  }),
+});
+
+// Run for Sqlite
+runPersistenceTestSuite({
+  name: "SqlitePersistence",
+  factory: () => {
+    const persistence = new SqlitePersistence(":memory:");
+    return {
+      persistence,
+      cleanup: () => persistence.close(),
+    };
+  },
+});