@seriousme/opifex 1.11.3 → 2.0.3

package/persistence/memory/memoryPersistence.ts

@@ -1,157 +1,16 @@
-import type {
-  Client,
-  ClientId,
-  Handler,
-  IPersistence,
-  IStore,
-  PacketId,
-  PacketIdStore,
-  PacketStore,
-  PublishPacket,
-  QoS,
-  RetainStore,
-  SubscriptionStore,
-  Topic,
-  TopicFilter,
-} from "../mod.ts";
-
-import { maxPacketId } from "../mod.ts";
-
-import { Trie } from "../deps.ts";
-import { assert } from "../../utils/mod.ts";
-
-type ClientSubscription = {
-  clientId: ClientId;
-  qos: QoS;
-};
-
-export class MemoryStore implements IStore {
-  existingSession: boolean = false;
-  clientId: ClientId;
-  private packetId: PacketId;
-  pendingIncoming: PacketIdStore;
-  pendingOutgoing: PacketStore;
-  pendingAckOutgoing: PacketIdStore;
-  subscriptions: SubscriptionStore;
-
-  constructor(clientId: ClientId) {
-    this.packetId = 0;
-    this.pendingIncoming = new Set();
-    this.pendingOutgoing = new Map();
-    this.pendingAckOutgoing = new Set();
-    this.subscriptions = new Map();
-    this.clientId = clientId;
-  }
-
-  nextId(): PacketId {
-    const currentId = this.packetId;
-    do {
-      this.packetId++;
-      if (this.packetId > maxPacketId) {
-        this.packetId = 0;
-      }
-    } while (
-      (this.pendingOutgoing.has(this.packetId) ||
-        this.pendingAckOutgoing.has(this.packetId)) &&
-      this.packetId !== currentId
-    );
-    assert(this.packetId !== currentId, "No unused packetId available");
-    return this.packetId;
-  }
-}
-
-export class MemoryPersistence implements IPersistence {
-  clientList: Map<ClientId, Client>;
-  retained: RetainStore;
-  private trie: Trie<ClientSubscription>;
+import { MqttPersistence } from "../basicPersistence.ts";
+import { MemoryStorage } from "./memoryStorage.ts";
 
+export class MemoryPersistence extends MqttPersistence {
   constructor() {
-    this.clientList = new Map();
-    this.retained = new Map();
-    this.trie = new Trie(true);
-  }
-
-  registerClient(clientId: ClientId, handler: Handler, clean: boolean): IStore {
-    const existingClient = this.clientList.get(clientId);
-    const store = !clean && existingClient
-      ? existingClient.store
-      : new MemoryStore(clientId);
-    this.clientList.set(clientId, { store, handler });
-    return store;
-  }
-
-  deregisterClient(clientId: ClientId): void {
-    const client = this.clientList.get(clientId);
-    if (client) {
-      this.unsubscribeAll(client.store);
-      this.clientList.delete(clientId);
-    }
-  }
-
-  subscribe(store: IStore, topicFilter: TopicFilter, qos: QoS): void {
-    const clientId = store.clientId;
-    if (!store.subscriptions.has(topicFilter)) {
-      store.subscriptions.set(topicFilter, qos);
-      this.trie.add(topicFilter, { clientId, qos });
-    }
-  }
-
-  unsubscribe(store: IStore, topicFilter: TopicFilter): void {
-    const clientId = store.clientId;
-    const qos = store.subscriptions.get(topicFilter);
-    if (qos !== undefined) {
-      store.subscriptions.delete(topicFilter);
-      this.trie.remove(topicFilter, { clientId, qos });
-    }
-  }
-
-  private unsubscribeAll(store: IStore) {
-    for (const [topicFilter, _qos] of store.subscriptions) {
-      this.unsubscribe(store, topicFilter);
-    }
-  }
-
-  publish(topic: Topic, packet: PublishPacket): void {
-    if (packet.retain) {
-      this.retained.set(packet.topic, packet);
-      if (packet.payload === undefined) {
-        this.retained.delete(packet.topic);
-      }
-    }
-
-    // dedup clients
-    const clients = new Map();
-    for (const { clientId, qos } of this.trie.match(topic)) {
-      const prevQos = clients.get(clientId);
-      if (!prevQos || prevQos < qos) {
-        clients.set(clientId, qos);
-      }
-    }
-
-    // publish the message to all clients
-    for (const [clientId, qos] of clients) {
-      const newPacket = Object.assign({}, packet);
-      newPacket.retain = false;
-      newPacket.qos = qos;
-      //  logger.debug(`publish ${topic} to client ${clientId}`);
-      const client = this.clientList.get(clientId);
-      client?.handler(newPacket);
-    }
-  }
-
-  handleRetained(clientId: ClientId): void {
-    const retainedTrie: Trie<ClientId> = new Trie();
-    const client = this.clientList.get(clientId);
-    const store = client?.store;
-    if (store) {
-      for (const [topicFilter, _qos] of store.subscriptions) {
-        retainedTrie.add(topicFilter, clientId);
-      }
-      for (const [topic, packet] of this.retained) {
-        if (retainedTrie.match(topic).length > 0) {
-          client?.handler(packet);
-        }
-      }
-    }
+    super(new MemoryStorage());
+  }
+  /**
+   * Convenient lifecycle method combining instance creation and initialization.
+   */
+  static async start(): Promise<MemoryPersistence> {
+    const persistence = new MemoryPersistence();
+    await persistence.initialize();
+    return persistence;
   }
 }

package/persistence/memory/memoryStorage.ts

@@ -0,0 +1,232 @@
+/**
+ * @module
+ * Volatile in-memory implementation of IStorageProvider.
+ * 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 { IStorageProvider, 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 IStorageProvider {
+  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,
 } 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(),
+    };
+  },
+});