@elliemae/pui-websocket-so 2.0.0

package/dist/cjs/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var index_exports = {};
+__export(index_exports, {
+  WebSocketSO: () => import_websocketSO.WebSocketSO
+});
+module.exports = __toCommonJS(index_exports);
+var import_websocketSO = require("./websocketSO.js");

package/dist/cjs/messageRouter.js

@@ -0,0 +1,111 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var messageRouter_exports = {};
+__export(messageRouter_exports, {
+  MessageRouter: () => MessageRouter
+});
+module.exports = __toCommonJS(messageRouter_exports);
+class MessageRouter {
+  #subscriptionManager;
+  #onEvent;
+  #logger;
+  /**
+   * @param {SubscriptionManager} subscriptionManager - manages pending requests and active subscriptions
+   * @param {EventCallback} onEvent - callback invoked when a server event matches an active subscription
+   * @param {Logger} logger - logger instance for debug/error output
+   */
+  constructor(subscriptionManager, onEvent, logger) {
+    this.#subscriptionManager = subscriptionManager;
+    this.#onEvent = onEvent;
+    this.#logger = logger;
+  }
+  /**
+   * Entry point for all messages received from the WebSocket server.
+   * Dispatches to the correct handler based on message type.
+   * @param {ServerMessage} message - incoming server message
+   */
+  handleMessage = (message) => {
+    switch (message.type) {
+      case "subscribe_ack":
+        this.#handleSubscribeAck(message);
+        break;
+      case "unsubscribe_ack":
+        this.#handleUnsubscribeAck(message);
+        break;
+      case "error":
+        this.#handleError(message);
+        break;
+      case "event":
+        this.#handleEvent(message);
+        break;
+      default:
+        this.#logger.debug(
+          `Unknown message type received: ${message.type}`
+        );
+    }
+  };
+  #handleSubscribeAck(message) {
+    const { correlationId, subscriptionId } = message;
+    const resolved = this.#subscriptionManager.resolvePendingRequest(
+      correlationId,
+      { subscriptionId }
+    );
+    if (!resolved) {
+      this.#logger.debug(
+        `Received subscribe_ack for unknown correlationId: ${correlationId}`
+      );
+    }
+  }
+  #handleUnsubscribeAck(message) {
+    const { correlationId } = message;
+    const resolved = this.#subscriptionManager.resolvePendingRequest(
+      correlationId,
+      void 0
+    );
+    if (!resolved) {
+      this.#logger.debug(
+        `Received unsubscribe_ack for unknown correlationId: ${correlationId}`
+      );
+    }
+  }
+  #handleError(message) {
+    const { correlationId, errors } = message;
+    const errorMessages = errors.map((e) => `${e.code}: ${e.message}`).join("; ");
+    const rejected = this.#subscriptionManager.rejectPendingRequest(
+      correlationId,
+      new Error(errorMessages)
+    );
+    if (!rejected) {
+      this.#logger.debug(
+        `Received error for unknown correlationId: ${correlationId}. Errors: ${errorMessages}`
+      );
+    }
+  }
+  #handleEvent(message) {
+    const { subscriptionId } = message;
+    const subscription = this.#subscriptionManager.getSubscription(subscriptionId);
+    if (!subscription) {
+      this.#logger.debug(
+        `Received event for unknown subscriptionId: ${subscriptionId}`
+      );
+      return;
+    }
+    this.#onEvent(message, subscription);
+  }
+}

package/dist/cjs/package.json

@@ -0,0 +1,7 @@
+{
+  "type": "commonjs",
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/dist/cjs/subscriptionManager.js

@@ -0,0 +1,224 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var subscriptionManager_exports = {};
+__export(subscriptionManager_exports, {
+  SubscriptionManager: () => SubscriptionManager
+});
+module.exports = __toCommonJS(subscriptionManager_exports);
+const DEFAULT_REQUEST_TIMEOUT_MS = 3e4;
+class SubscriptionManager {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  #pendingRequests = /* @__PURE__ */ new Map();
+  #subscriptions = /* @__PURE__ */ new Map();
+  /** Reverse index: composite lookup key → subscriptionId for O(1) duplicate detection. */
+  #keyIndex = /* @__PURE__ */ new Map();
+  #requestTimeoutMs;
+  /**
+   * @param {number} [requestTimeoutMs=30000] - timeout in ms before a pending request is auto-rejected
+   */
+  constructor(requestTimeoutMs = DEFAULT_REQUEST_TIMEOUT_MS) {
+    this.#requestTimeoutMs = requestTimeoutMs;
+  }
+  /**
+   * Register a pending request that will be resolved/rejected when the
+   * server responds with a message matching the given correlationId.
+   * @param {string} correlationId - unique id correlating request to response
+   * @param {Function} resolve - callback invoked on success
+   * @param {Function} reject - callback invoked on failure or timeout
+   */
+  addPendingRequest(correlationId, resolve, reject) {
+    const existing = this.#pendingRequests.get(correlationId);
+    if (existing) {
+      clearTimeout(existing.timeoutId);
+      existing.reject(
+        new Error(`Pending request replaced (correlationId: ${correlationId})`)
+      );
+    }
+    const timeoutId = setTimeout(() => {
+      this.#pendingRequests.delete(correlationId);
+      reject(
+        new Error(
+          `Request timed out after ${this.#requestTimeoutMs}ms (correlationId: ${correlationId})`
+        )
+      );
+    }, this.#requestTimeoutMs);
+    this.#pendingRequests.set(correlationId, { resolve, reject, timeoutId });
+  }
+  /**
+   * Resolve a pending request with a successful result.
+   * @param {string} correlationId - unique id of the pending request
+   * @param {*} value - the value to resolve with
+   * @returns {boolean} true if the request was found and resolved
+   */
+  resolvePendingRequest(correlationId, value) {
+    const pending = this.#pendingRequests.get(correlationId);
+    if (!pending) return false;
+    clearTimeout(pending.timeoutId);
+    this.#pendingRequests.delete(correlationId);
+    pending.resolve(value);
+    return true;
+  }
+  /**
+   * Reject a pending request with an error.
+   * @param {string} correlationId - unique id of the pending request
+   * @param {Error} error - the error to reject with
+   * @returns {boolean} true if the request was found and rejected
+   */
+  rejectPendingRequest(correlationId, error) {
+    const pending = this.#pendingRequests.get(correlationId);
+    if (!pending) return false;
+    clearTimeout(pending.timeoutId);
+    this.#pendingRequests.delete(correlationId);
+    pending.reject(error);
+    return true;
+  }
+  /**
+   * Find an existing subscription matching the given resource criteria and guest.
+   * Uses a secondary key index for O(1) lookup.
+   * @param {Omit<Subscription, 'subscriptionId' | 'refCount'>} criteria - fields to match
+   * @returns {Subscription | undefined} matching subscription or undefined
+   */
+  findExistingSubscription(criteria) {
+    const key = SubscriptionManager.#buildLookupKey(criteria);
+    const subscriptionId = this.#keyIndex.get(key);
+    if (!subscriptionId) return void 0;
+    return this.#subscriptions.get(subscriptionId);
+  }
+  /**
+   * Register a new active subscription. Initialises refCount to 1.
+   * @param {Omit<Subscription, 'refCount'>} subscription - subscription data (refCount is set internally)
+   */
+  addSubscription(subscription) {
+    const entry = {
+      ...subscription,
+      filter: subscription.filter ? JSON.parse(JSON.stringify(subscription.filter)) : void 0,
+      refCount: 1
+    };
+    this.#subscriptions.set(subscription.subscriptionId, entry);
+    this.#keyIndex.set(
+      SubscriptionManager.#buildLookupKey(entry),
+      subscription.subscriptionId
+    );
+  }
+  /**
+   * Increment the reference count for an existing subscription.
+   * @param {string} subscriptionId - subscription to increment
+   * @returns {number} the new refCount, or -1 if the subscription was not found
+   */
+  incrementRefCount(subscriptionId) {
+    const sub = this.#subscriptions.get(subscriptionId);
+    if (!sub) return -1;
+    sub.refCount += 1;
+    return sub.refCount;
+  }
+  /**
+   * Decrement the reference count and remove when it reaches 0.
+   * @param {string} subscriptionId - subscription to decrement
+   * @returns {number} the new refCount (0 means removed), or -1 if not found
+   */
+  decrementRefCount(subscriptionId) {
+    const sub = this.#subscriptions.get(subscriptionId);
+    if (!sub) return -1;
+    sub.refCount -= 1;
+    if (sub.refCount <= 0) {
+      this.#keyIndex.delete(SubscriptionManager.#buildLookupKey(sub));
+      this.#subscriptions.delete(subscriptionId);
+      return 0;
+    }
+    return sub.refCount;
+  }
+  /**
+   * Unconditionally remove a subscription regardless of refCount.
+   * Used during reconnection to replace old entries.
+   * @param {string} subscriptionId - subscription to remove
+   * @returns {boolean} true if the subscription existed and was removed
+   */
+  removeSubscription(subscriptionId) {
+    const sub = this.#subscriptions.get(subscriptionId);
+    if (sub) {
+      this.#keyIndex.delete(SubscriptionManager.#buildLookupKey(sub));
+    }
+    return this.#subscriptions.delete(subscriptionId);
+  }
+  /**
+   * Retrieve subscription metadata by id.
+   * @param {string} subscriptionId - subscription to look up
+   * @returns {Subscription | undefined} the subscription, or undefined if not found
+   */
+  getSubscription(subscriptionId) {
+    return this.#subscriptions.get(subscriptionId);
+  }
+  /**
+   * Check whether a subscription is currently active.
+   * @param {string} subscriptionId - subscription to check
+   * @returns {boolean} true if the subscription exists
+   */
+  hasSubscription(subscriptionId) {
+    return this.#subscriptions.has(subscriptionId);
+  }
+  /**
+   * Returns all active subscriptions.
+   * Used for re-subscribing after a reconnection.
+   * @returns {Subscription[]} array of active subscriptions
+   */
+  getAllSubscriptions() {
+    return Array.from(this.#subscriptions.values());
+  }
+  /**
+   * Clean up all pending requests and subscriptions.
+   * Rejects any outstanding pending requests.
+   */
+  dispose() {
+    this.#pendingRequests.forEach((pending) => {
+      clearTimeout(pending.timeoutId);
+      pending.reject(new Error("WebSocket scripting object disposed"));
+    });
+    this.#pendingRequests.clear();
+    this.#subscriptions.clear();
+    this.#keyIndex.clear();
+  }
+  /**
+   * Compute the canonical lookup key for a set of subscription criteria.
+   * Exposed so callers can track in-flight subscribes by the same key.
+   * @param {Omit<Subscription, 'subscriptionId' | 'refCount'>} criteria - subscription fields
+   * @returns {string} composite lookup key
+   */
+  static buildLookupKey(criteria) {
+    return SubscriptionManager.#buildLookupKey(criteria);
+  }
+  /**
+   * Builds a canonical composite key for O(1) subscription lookup.
+   * Uses NUL (\0) as separator to avoid collisions with real values.
+   * Filter keys are sorted for order-independent comparison.
+   * @param {Pick<Subscription, 'guestId' | 'resource' | 'resourceId' | 'filter'>} sub - subscription fields
+   * @returns {string} composite lookup key
+   */
+  static #buildLookupKey(sub) {
+    const { guestId, resource, resourceId, filter } = sub;
+    if (resourceId != null) {
+      return `${guestId}\0${resource}\0rid:${resourceId}`;
+    }
+    if (filter != null) {
+      const sortedKeys = Object.keys(filter).sort();
+      const canonical = sortedKeys.map((k) => `${k}=${filter[k].join(",")}`).join("&");
+      return `${guestId}\0${resource}\0f:${canonical}`;
+    }
+    return `${guestId}\0${resource}`;
+  }
+}

package/dist/cjs/types.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);