@seriousme/opifex 1.11.2 → 2.0.3

package/persistence/sqlite/sqliteStorage.ts

@@ -0,0 +1,324 @@
+import type sqlite from "node:sqlite";
+import type { ClientId, PacketId, Topic, TopicFilter } from "../deps.ts";
+import type {
+  ClientRegistrationResult,
+  ClientSubscription,
+  ExtPublishPacket,
+  ShareName,
+} from "../persistence.ts";
+import { PacketDirection } from "../storage.ts";
+import type { IStorageProvider, StoredSubscription } from "../storage.ts";
+import { topicFilterToRegExp } from "../deps.ts";
+import {
+  deleteClientState,
+  initializeDatabase,
+  prepareAllStatements,
+} from "./sqliteDatabase.ts";
+import type { AllStatements } from "./sqliteDatabase.ts";
+
+const SQLITE_DATABASE_URL = ":memory:";
+
+function serializePacket(
+  packet: ExtPublishPacket,
+): { packetJson: string; payloadBlob: Uint8Array | null } {
+  const packetJson = JSON.stringify({ ...packet, payload: undefined });
+  const payloadBlob = packet.payload ? packet.payload : null;
+  return { packetJson, payloadBlob };
+}
+
+function deserializePacket(
+  packetJson: string,
+  payloadBlob: Uint8Array | null,
+): ExtPublishPacket {
+  const packet = JSON.parse(packetJson) as ExtPublishPacket;
+  if (payloadBlob) {
+    packet.payload = payloadBlob;
+  }
+  return packet;
+}
+
+export class SqliteStorage implements IStorageProvider {
+  private db: sqlite.DatabaseSync;
+
+  private statements: AllStatements;
+
+  constructor(db: string | sqlite.DatabaseSync = SQLITE_DATABASE_URL) {
+    if (typeof db === "string") {
+      this.db = initializeDatabase(db);
+    } else {
+      this.db = db;
+    }
+    this.statements = prepareAllStatements(this.db);
+  }
+
+  initialize(): Promise<void> {
+    return Promise.resolve();
+  }
+
+  close(): Promise<void> {
+    this.db.close();
+    return Promise.resolve();
+  }
+
+  // --- Sessions ---
+  saveSession(
+    clientId: ClientId,
+    session: ClientRegistrationResult,
+  ): Promise<void> {
+    this.statements.saveSession.run(clientId, JSON.stringify(session));
+    return Promise.resolve();
+  }
+
+  getSession(clientId: ClientId): Promise<ClientRegistrationResult | null> {
+    const row = this.statements.getSession.get(clientId) as {
+      session_data: string;
+    } | undefined;
+    return Promise.resolve(row ? JSON.parse(row.session_data) : null);
+  }
+
+  deleteSession(clientId: ClientId): Promise<void> {
+    deleteClientState(this.db, clientId);
+    return Promise.resolve();
+  }
+
+  async *listAllSessions(): AsyncIterableIterator<
+    { clientId: ClientId; session: ClientRegistrationResult }
+  > {
+    for (
+      const row of this.statements.listAllSessions
+        .iterate() as IterableIterator<
+          { client_id: string; session_data: string }
+        >
+    ) {
+      yield {
+        clientId: row.client_id,
+        session: JSON.parse(row.session_data),
+      };
+    }
+  }
+
+  // --- Subscriptions ---
+  saveSubscription(clientId: ClientId, sub: ClientSubscription): Promise<void> {
+    const subData = {
+      qos: sub.qos,
+      noLocal: sub.noLocal,
+      retainAsPublished: sub.retainAsPublished,
+      retainHandling: sub.retainHandling,
+      subscriptionIdentifier: sub.subscriptionIdentifier,
+    };
+
+    this.statements.saveSubscription.run(
+      clientId,
+      sub.topicFilter,
+      sub.shareName,
+      JSON.stringify(subData),
+    );
+    return Promise.resolve();
+  }
+
+  deleteSubscription(
+    clientId: ClientId,
+    topicFilter: TopicFilter,
+    shareName: ShareName,
+  ): Promise<void> {
+    this.statements.deleteSubscription.run(clientId, topicFilter, shareName);
+    return Promise.resolve();
+  }
+
+  async *listSubscriptions(
+    clientId: ClientId,
+  ): AsyncIterableIterator<ClientSubscription> {
+    const rows = this.statements.listSubscriptions.all(clientId) as Array<{
+      topic: string;
+      share_name: string;
+      subscription_data: string;
+    }>;
+
+    for (const row of rows) {
+      const sub = JSON.parse(row.subscription_data);
+      sub.topicFilter = row.topic;
+      sub.shareName = row.share_name;
+      yield sub;
+    }
+  }
+
+  async *listAllSubscriptions(): AsyncIterableIterator<StoredSubscription> {
+    const rows = this.statements.listAllSubscriptions.all() as Array<{
+      client_id: string;
+      topic: string;
+      share_name: string;
+      subscription_data: string;
+    }>;
+
+    for (const row of rows) {
+      const sub = JSON.parse(row.subscription_data);
+      sub.topicFilter = row.topic;
+      sub.shareName = row.share_name;
+      sub.clientId = row.client_id;
+      yield sub;
+    }
+  }
+
+  // --- Pending Packets (Incoming & Outgoing) ---
+  savePendingPacket(
+    clientId: ClientId,
+    direction: PacketDirection,
+    packet: ExtPublishPacket,
+  ): Promise<void> {
+    if (packet.id === undefined) return Promise.resolve();
+
+    const { packetJson, payloadBlob } = serializePacket(packet);
+    const stmt = direction === PacketDirection.Incoming
+      ? this.statements.saveIncoming
+      : this.statements.saveOutgoing;
+
+    stmt.run(clientId, packet.id, packetJson, payloadBlob);
+    return Promise.resolve();
+  }
+
+  getPendingPacket(
+    clientId: ClientId,
+    direction: PacketDirection,
+    packetId: PacketId,
+  ): Promise<ExtPublishPacket | null> {
+    const stmt = direction === PacketDirection.Incoming
+      ? this.statements.getIncoming
+      : this.statements.getOutgoing;
+
+    const row = stmt.get(clientId, packetId) as {
+      packet: string;
+      payload: Uint8Array | null;
+      expires_at: number | null;
+    } | undefined;
+
+    if (!row) return Promise.resolve(null);
+
+    // Filter out expired packets
+    if (row.expires_at !== null && row.expires_at <= Date.now()) {
+      return Promise.resolve(null);
+    }
+
+    return Promise.resolve(deserializePacket(row.packet, row.payload));
+  }
+
+  updatePendingPacket(
+    clientId: ClientId,
+    direction: PacketDirection,
+    packetId: PacketId,
+    dup: boolean,
+  ): Promise<boolean> {
+    const stmt = direction === PacketDirection.Incoming
+      ? this.statements.updateIncomingDup
+      : this.statements.updateOutgoingDup;
+
+    // Pass "true" of "false" as JSON literal , passing a boolean would make it 1 or 0
+    const info = stmt.run(dup ? "true" : "false", clientId, packetId);
+
+    // info.changes returns number of updated records
+    return Promise.resolve(info.changes > 0);
+  }
+
+  deletePendingPacket(
+    clientId: ClientId,
+    direction: PacketDirection,
+    packetId: PacketId,
+  ): Promise<boolean> {
+    const stmt = direction === PacketDirection.Incoming
+      ? this.statements.deleteIncoming
+      : this.statements.deleteOutgoing;
+    const info = stmt.run(clientId, packetId);
+
+    return Promise.resolve(info.changes > 0);
+  }
+
+  async *listPendingPackets(
+    clientId: ClientId,
+    direction: PacketDirection,
+  ): AsyncIterableIterator<ExtPublishPacket> {
+    const stmt = direction === PacketDirection.Incoming
+      ? this.statements.listIncoming
+      : this.statements.listOutgoing;
+
+    const rows = stmt.all(clientId) as Array<{
+      packet: string;
+      payload: Uint8Array | null;
+      expires_at: number | null;
+    }>;
+
+    for (const row of rows) {
+      yield deserializePacket(row.packet, row.payload);
+    }
+  }
+
+  // --- ACKs ---
+  savePendingAck(clientId: ClientId, packetId: PacketId): Promise<void> {
+    this.statements.saveAck.run(clientId, packetId);
+    return Promise.resolve();
+  }
+
+  hasPendingAck(clientId: ClientId, packetId: PacketId): Promise<boolean> {
+    const row = this.statements.hasAck.get(clientId, packetId);
+    return Promise.resolve(row !== undefined);
+  }
+
+  deletePendingAck(clientId: ClientId, packetId: PacketId): Promise<boolean> {
+    const info = this.statements.deleteAck.run(clientId, packetId);
+    return Promise.resolve(info.changes > 0);
+  }
+
+  async *listPendingAcks(clientId: ClientId): AsyncIterableIterator<PacketId> {
+    const rows = this.statements.listAcks.all(clientId) as Array<{
+      packet_id: number;
+    }>;
+
+    for (const row of rows) {
+      yield row.packet_id as PacketId;
+    }
+  }
+
+  // --- Retained Messages ---
+  saveRetained(topic: Topic, packet: ExtPublishPacket): Promise<void> {
+    const { packetJson, payloadBlob } = serializePacket(packet);
+    this.statements.saveRetained.run(topic, packetJson, payloadBlob);
+    return Promise.resolve();
+  }
+
+  deleteRetained(topic: Topic): Promise<void> {
+    this.statements.deleteRetained.run(topic);
+    return Promise.resolve();
+  }
+
+  async *listRetainedMatches(
+    topicFilter: TopicFilter,
+  ): AsyncIterableIterator<ExtPublishPacket> {
+    let hasWildcards = false;
+    const sqlLike = topicFilter.replace(/\/#|#|\+/g, () => {
+      hasWildcards = true;
+      return "%";
+    });
+
+    if (!hasWildcards) {
+      const rows = this.statements.getRetainedExact.all(topicFilter) as Array<{
+        packet: string;
+        payload: Uint8Array | null;
+      }>;
+
+      for (const row of rows) {
+        yield deserializePacket(row.packet, row.payload);
+      }
+    } else {
+      const rows = this.statements.listRetainedLike.all(sqlLike) as Array<{
+        topic: string;
+        packet: string;
+        payload: Uint8Array | null;
+      }>;
+
+      const regex = topicFilterToRegExp(topicFilter);
+      for (const row of rows) {
+        if (regex.test(row.topic)) {
+          yield deserializePacket(row.packet, row.payload);
+        }
+      }
+    }
+  }
+}

package/persistence/storage.ts

@@ -0,0 +1,84 @@
+import type { ClientId, PacketId, Topic, TopicFilter } from "./deps.ts";
+import type {
+  ClientRegistrationResult,
+  ClientSubscription,
+  ExtPublishPacket,
+  ShareName,
+} from "./persistence.ts";
+
+export type StoredSubscription = ClientSubscription & { clientId: ClientId };
+export const PacketDirection = {
+  Incoming: 0,
+  Outgoing: 1,
+} as const;
+
+export type PacketDirection =
+  typeof PacketDirection[keyof typeof PacketDirection];
+
+export interface IStorageProvider {
+  initialize(): Promise<void>;
+  close?(): Promise<void>;
+
+  // --- Session Storage ---
+  saveSession(
+    clientId: ClientId,
+    session: ClientRegistrationResult,
+  ): Promise<void>;
+  getSession(clientId: ClientId): Promise<ClientRegistrationResult | null>;
+  deleteSession(clientId: ClientId): Promise<void>;
+  listAllSessions(): AsyncIterableIterator<
+    { clientId: ClientId; session: ClientRegistrationResult }
+  >;
+
+  // --- Subscription Storage ---
+  saveSubscription(clientId: ClientId, sub: ClientSubscription): Promise<void>;
+  deleteSubscription(
+    clientId: ClientId,
+    topicFilter: TopicFilter,
+    shareName: ShareName,
+  ): Promise<void>;
+  listSubscriptions(
+    clientId: ClientId,
+  ): AsyncIterableIterator<ClientSubscription>;
+  listAllSubscriptions(): AsyncIterableIterator<StoredSubscription>;
+
+  // --- Pending Packet Storage (Incoming & Outgoing) ---
+  savePendingPacket(
+    clientId: ClientId,
+    direction: PacketDirection,
+    packet: ExtPublishPacket,
+  ): Promise<void>;
+  getPendingPacket(
+    clientId: ClientId,
+    direction: PacketDirection,
+    packetId: PacketId,
+  ): Promise<ExtPublishPacket | null>;
+  updatePendingPacket(
+    clientId: ClientId,
+    direction: PacketDirection,
+    packetId: PacketId,
+    dup: boolean,
+  ): Promise<boolean>;
+  deletePendingPacket(
+    clientId: ClientId,
+    direction: PacketDirection,
+    packetId: PacketId,
+  ): Promise<boolean>;
+  listPendingPackets(
+    clientId: ClientId,
+    direction: PacketDirection,
+  ): AsyncIterableIterator<ExtPublishPacket>;
+
+  // --- Pending Acknowledgment Storage ---
+  savePendingAck(clientId: ClientId, packetId: PacketId): Promise<void>;
+  hasPendingAck(clientId: ClientId, packetId: PacketId): Promise<boolean>;
+  deletePendingAck(clientId: ClientId, packetId: PacketId): Promise<boolean>;
+  listPendingAcks(clientId: ClientId): AsyncIterableIterator<PacketId>;
+
+  // --- Retained Message Storage ---
+  saveRetained(topic: Topic, packet: ExtPublishPacket): Promise<void>;
+  deleteRetained(topic: Topic): Promise<void>;
+  listRetainedMatches(
+    topicFilter: TopicFilter,
+  ): AsyncIterableIterator<ExtPublishPacket>;
+}

package/server/config.ts

@@ -0,0 +1,65 @@
+/**
+ * Server configuration parameters
+ */
+
+import { MQTTLevel } from "./deps.ts";
+import type { ProtocolLevel } from "./deps.ts";
+
+export const QueueMode = {
+  DiscardNewest: 0, // when maxQueued messages has been reached do not accept new ones
+  DiscardOldest: 1, // when maxQueued messages has been reached discard the oldest message to make room
+} as const;
+
+export type QueueMode = typeof QueueMode[keyof typeof QueueMode];
+
+export const defaultConfiguration = {
+  context: {
+    maxInflightMessages: 20, // max number of messages sent to a client waiting for puback or pubcomp
+    maxQueuedMessages: 1000, // max number of messages in-store per client
+    maxSessionExpiryInterval: 86400, // 1 day
+    maximumConnectPacketSize: 4000, // max size on Connect packets, keep this resonably small to avoid risk on DoS
+    maximumIncomingPacketSize: 4000, // max size for other incoming packets
+    maximumOutgoingPacketSize: 4000, // max size for all outgoing packets
+    maximumQos: 2, // maximum QoS level accepted by the server
+    maxTopicLevels: 50, // topic levels on Topics and TopicFilters, keep this resonably small to avoid risk on DoS
+    preconnectTimeoutMs: 3000, // if the client does not complete connect within this time, hangup
+    protocols: [MQTTLevel.v4 as ProtocolLevel, MQTTLevel.v5 as ProtocolLevel],
+    provideReasonStrings: false, // provide reasonStrings in ack and disconnect messages
+    queueStrategy: QueueMode.DiscardNewest, // see definition of QueueMode
+    receiveMaximum: 20, // maximum incoming messages on the server per client waiting for pubComp
+    retainAvailable: true, // messages will be retained when retain flag is set
+    serverKeepAlive: 100, // 100 seconds
+    sharedSubscriptionAvailable: true, // clients can use shared subscriptions
+    subscriptionIdentifierAvailable: true, // clients can use subscriptions identifiers
+    topicAliasMaximum: 5, // max number of incoming topic aliases the server will acceptper client, 0 = none
+    wildcardSubscriptionAvailable: true, // clients can use wildcard subscriptions
+  },
+};
+
+type DefaultContext = typeof defaultConfiguration.context;
+type BaseContext =
+  & Omit<DefaultContext, "sessionExpiryInterval" | "queueStrategy">
+  & {
+    maxSessionExpiryInterval: number | undefined;
+    queueStrategy: QueueMode;
+  };
+
+type ContextInput = Partial<BaseContext>;
+
+export type Configuration = {
+  context: BaseContext;
+};
+
+export type ConfigurationInput = {
+  context?: ContextInput;
+};
+
+// Helper function to safely merge consumer config with defaults
+export function createConfiguration(input?: ConfigurationInput): Configuration {
+  return {
+    context: {
+      ...defaultConfiguration.context,
+      ...input?.context,
+    },
+  };
+}