@dooboostore/simple-boot-http-server 1.0.23 → 1.0.24

package/dist/esm/websocket/WebSocketManager.js

@@ -0,0 +1,622 @@
+var __decorate = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = function(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var _a, _b;
+import { Sim } from "@dooboostore/simple-boot";
+import { WebSocket } from "ws";
+import { IntentManager } from "@dooboostore/simple-boot";
+import { RouterManager } from "@dooboostore/simple-boot";
+import { Intent } from "@dooboostore/simple-boot";
+import { RandomUtils } from "@dooboostore/core";
+import { Subject } from "@dooboostore/core";
+const isTopicRequest = (obj) => {
+  return typeof obj === "object" && obj !== null && "uuid" in obj && typeof obj.uuid === "string" && (obj.type === void 0 || obj.type === "intent" || obj.type === "router") && (obj.body === void 0 || true);
+};
+const isTopicSubscribeRequest = (obj) => {
+  return typeof obj === "object" && obj !== null && "type" in obj && obj.type === "subscribe" && "target" in obj && typeof obj.target === "string" && "uuid" in obj && typeof obj.uuid === "string" && (obj.body === void 0 || true);
+};
+const isTopicUnsubscribeRequest = (obj) => {
+  return typeof obj === "object" && obj !== null && "type" in obj && obj.type === "unsubscribe" && "uuid" in obj && typeof obj.uuid === "string";
+};
+const isTopicResponse = (obj) => {
+  return typeof obj === "object" && obj !== null && "state" in obj && (obj.state === "success" || obj.state === "error") && "target" in obj && typeof obj.target === "string" && "uuid" in obj && typeof obj.uuid === "string" && "body" in obj;
+};
+const isTopicServerEventRequest = (obj) => {
+  return typeof obj === "object" && obj !== null && "type" in obj && obj.type === "event" && "uuid" in obj && typeof obj.uuid === "string" && "eventUUID" in obj && typeof obj.eventUUID === "string" && "event" in obj && typeof obj.event === "string" && (obj.body === void 0 || true);
+};
+const isTopicServerEventResponse = (obj) => {
+  return typeof obj === "object" && obj !== null && "type" in obj && obj.type === "event" && "uuid" in obj && typeof obj.uuid === "string" && "eventUUID" in obj && typeof obj.eventUUID === "string" && (obj.body === void 0 || true);
+};
+const isTopicServerEventUnSubscribeRequest = (obj) => {
+  return typeof obj === "object" && obj !== null && "type" in obj && obj.type === "unsubscribe" && "uuid" in obj && typeof obj.uuid === "string";
+};
+let WebSocketManager = class WebSocketManager2 {
+  constructor(intentManager, routerManager) {
+    this.intentManager = intentManager;
+    this.routerManager = routerManager;
+    this.clients = /* @__PURE__ */ new Map();
+    this.eventSubscriptions = /* @__PURE__ */ new Map();
+    this.subject = new Subject();
+  }
+  get observable() {
+    return this.subject.asObservable();
+  }
+  connect(wsSet) {
+    this.clients.set(wsSet, []);
+    console.log("WebSocket connected:", wsSet.request.url);
+  }
+  close(wsSet) {
+    this.removeAllClientsByWebSocketSet(wsSet);
+    this.clients.delete(wsSet);
+    console.log("WebSocket disconnected:", wsSet.request.url);
+  }
+  setClientTopic(wsSet, uuid, target, subscribeBody) {
+    const clientTopics = this.clients.get(wsSet);
+    if (clientTopics && !clientTopics.find((it) => it.uuid === uuid)) {
+      clientTopics.push({ uuid, target, subscribeBody });
+      this.clients.set(wsSet, clientTopics);
+    } else if (clientTopics) {
+      throw { message: "Already subscribed topic" };
+    }
+  }
+  findAllClientsByTarget(target) {
+    const results = [];
+    for (const [wsSet, topics] of Array.from(this.clients.entries())) {
+      const find = topics.find((it) => it.target === target);
+      if (find) {
+        results.push({ ...find, webSocketSet: wsSet });
+      }
+    }
+    return results;
+  }
+  findClientsByTarget(target) {
+    for (const [wsSet, topics] of Array.from(this.clients.entries())) {
+      const find = topics.find((it) => it.target === target);
+      if (find) {
+        return { ...find, webSocketSet: wsSet };
+      }
+    }
+  }
+  removeClientByUUID(uuid) {
+    for (const [wsSet, topics] of Array.from(this.clients.entries())) {
+      const findIndex = topics.findIndex((it) => it.uuid === uuid);
+      if (findIndex >= 0) {
+        topics.splice(findIndex, 1);
+        this.clients.set(wsSet, topics);
+        this.eventSubscriptions.delete(uuid);
+        return true;
+      }
+    }
+    return false;
+  }
+  findClientByUUID(uuid) {
+    for (const [wsSet, topics] of Array.from(this.clients.entries())) {
+      const find = topics.find((it) => it.uuid === uuid);
+      if (find) {
+        return { ...find, webSocketSet: wsSet };
+      }
+    }
+    return void 0;
+  }
+  sendDataByUUID({ uuid, body }) {
+    const client = this.findClientByUUID(uuid);
+    if (client) {
+      const data = {
+        state: "success",
+        target: client.target,
+        uuid,
+        body
+      };
+      this.sendTopic(client.webSocketSet, data);
+      return true;
+    }
+    return false;
+  }
+  sendUnSubscribeByUUID({ uuid }) {
+    const client = this.findClientByUUID(uuid);
+    if (client) {
+      const data = {
+        type: "unsubscribe",
+        uuid
+      };
+      this.removeClientByUUID(uuid);
+      this.sendTopic(client.webSocketSet, data);
+      return true;
+    }
+    return false;
+  }
+  sendAllDataByTarget({ target, body }) {
+    const clients = this.findAllClientsByTarget(target);
+    clients.forEach((it) => {
+      const data = {
+        state: "success",
+        target: it.target,
+        uuid: it.uuid,
+        body
+      };
+      this.sendTopic(it.webSocketSet, data);
+    });
+    return clients.length;
+  }
+  sendAllUnSubscribeByTarget({ target }) {
+    const clients = this.findAllClientsByTarget(target);
+    clients.forEach((it) => {
+      const data = {
+        type: "unsubscribe",
+        uuid: it.uuid
+      };
+      this.removeClientByUUID(it.uuid);
+      this.sendTopic(it.webSocketSet, data);
+    });
+    return clients.length;
+  }
+  sendEventDataByUUID({ uuid, event, body }, config) {
+    const client = this.findClientByUUID(uuid);
+    if (client) {
+      const eventUUID = RandomUtils.uuid4();
+      const eventTopic = {
+        type: "event",
+        uuid,
+        // target: client.target,
+        eventUUID,
+        event,
+        body
+      };
+      if (config.responseCallBack) {
+        this.addEventSubscribes(uuid, eventUUID, config.responseCallBack);
+      }
+      this.sendTopic(client.webSocketSet, eventTopic);
+      return eventUUID;
+    }
+    return void 0;
+  }
+  sendEventDataByUUIDPromise({ uuid, event, body }, config) {
+    return new Promise((resolve, reject) => {
+      let timeoutId;
+      let eventUUIDForCleanup;
+      if (config?.responseTimeout !== void 0) {
+        timeoutId = setTimeout(() => {
+          if (eventUUIDForCleanup) {
+            const subscriptions = this.eventSubscriptions.get(uuid);
+            if (subscriptions) {
+              subscriptions.delete(eventUUIDForCleanup);
+              if (subscriptions.size <= 0) {
+                this.eventSubscriptions.delete(uuid);
+              }
+            }
+          }
+          reject(new Error("WebSocket event response timeout for UUID: " + uuid));
+        }, config.responseTimeout);
+      }
+      const eventUUID = this.sendEventDataByUUID({ uuid, event, body }, {
+        responseCallBack: (data) => {
+          if (timeoutId)
+            clearTimeout(timeoutId);
+          resolve(data);
+        }
+      });
+      eventUUIDForCleanup = eventUUID;
+      if (!eventUUID) {
+        if (timeoutId)
+          clearTimeout(timeoutId);
+        reject(new Error("WebSocket client not found for UUID: " + uuid));
+      }
+    });
+  }
+  async sendEventDataByUUIDPromiseSettled({ uuid, event, body }, config) {
+    try {
+      const value = await this.sendEventDataByUUIDPromise({ uuid, event, body }, config);
+      return { status: "fulfilled", value };
+    } catch (reason) {
+      return { status: "rejected", reason };
+    }
+  }
+  sendAllEventDataByTargetPromise({ target, event, body }, config) {
+    const clients = this.findAllClientsByTarget(target);
+    const promises = clients.map((it) => {
+      return this.sendEventDataByUUIDPromise({ uuid: it.uuid, event, body }, config).then((result) => ({
+        body: result,
+        uuid: it.uuid
+      }));
+    });
+    return Promise.all(promises);
+  }
+  sendAllEventDataByTargetPromiseSettled({ target, event, body }, config) {
+    const clients = this.findAllClientsByTarget(target);
+    const promises = clients.map((it) => {
+      return this.sendEventDataByUUIDPromise({ uuid: it.uuid, event, body }, config).then((result) => ({
+        body: result,
+        uuid: it.uuid
+      }));
+    });
+    return Promise.allSettled(promises);
+  }
+  sendAllEventDataByTarget({ target, event, body }, config) {
+    const clients = this.findAllClientsByTarget(target);
+    clients.forEach((it) => {
+      const eventUUID = RandomUtils.uuid4();
+      const eventTopic = {
+        type: "event",
+        uuid: it.uuid,
+        // target: it.target,
+        eventUUID,
+        event,
+        body
+      };
+      if (config?.responseCallBack) {
+        this.addEventSubscribes(it.uuid, eventUUID, config?.responseCallBack);
+      }
+      this.sendTopic(it.webSocketSet, eventTopic);
+    });
+    return clients.length;
+  }
+  addEventSubscribes(uuid, eventUUID, eventResponseCallBack) {
+    let eventMap = this.eventSubscriptions.get(uuid);
+    if (eventMap) {
+      eventMap.set(eventUUID, eventResponseCallBack);
+    } else {
+      eventMap = /* @__PURE__ */ new Map();
+      eventMap.set(eventUUID, eventResponseCallBack);
+      this.eventSubscriptions.set(uuid, eventMap);
+    }
+  }
+  getOpenClients() {
+    return Array.from(this.clients.keys()).filter((it) => it.socket.readyState === WebSocket.OPEN);
+  }
+  isBinaryPayload(value) {
+    if (!value) {
+      return false;
+    }
+    if (Buffer.isBuffer(value)) {
+      return true;
+    }
+    if (typeof Uint8Array !== "undefined" && value instanceof Uint8Array) {
+      return true;
+    }
+    if (typeof ArrayBuffer !== "undefined" && value instanceof ArrayBuffer) {
+      return true;
+    }
+    if (value && typeof value === "object" && "buffer" in value) {
+      const bufferValue = value.buffer;
+      return Buffer.isBuffer(bufferValue) || bufferValue instanceof Uint8Array || bufferValue instanceof ArrayBuffer;
+    }
+    return false;
+  }
+  hasBinaryPayload(value) {
+    if (this.isBinaryPayload(value)) {
+      return true;
+    }
+    if (Array.isArray(value)) {
+      return value.some((item) => this.hasBinaryPayload(item));
+    }
+    if (value && typeof value === "object") {
+      return Object.keys(value).some((key) => this.hasBinaryPayload(value[key]));
+    }
+    return false;
+  }
+  buildBinaryTopic(topic) {
+    const fileRefs = /* @__PURE__ */ new Map();
+    const fileEntries = [];
+    let fileIndex = 0;
+    const registerFile = (value) => {
+      const existing = fileRefs.get(value);
+      if (existing) {
+        return existing;
+      }
+      const id = `f${++fileIndex}`;
+      fileRefs.set(value, id);
+      let name = "file";
+      let mime = "application/octet-stream";
+      let buffer = Buffer.alloc(0);
+      if (Buffer.isBuffer(value)) {
+        buffer = value;
+      } else if (value instanceof Uint8Array) {
+        buffer = Buffer.from(value);
+      } else if (value instanceof ArrayBuffer) {
+        buffer = Buffer.from(value);
+      } else if (value && typeof value === "object" && "buffer" in value) {
+        const fileLike = value;
+        if (typeof fileLike.name === "string") {
+          name = fileLike.name || name;
+        }
+        if (typeof fileLike.mime === "string") {
+          mime = fileLike.mime || mime;
+        }
+        const innerBuffer = fileLike.buffer;
+        if (Buffer.isBuffer(innerBuffer)) {
+          buffer = innerBuffer;
+        } else if (innerBuffer instanceof Uint8Array) {
+          buffer = Buffer.from(innerBuffer);
+        } else if (innerBuffer instanceof ArrayBuffer) {
+          buffer = Buffer.from(innerBuffer);
+        }
+      }
+      fileEntries.push({ id, name, mime, buffer });
+      return id;
+    };
+    const replaceFiles = (value) => {
+      if (this.isBinaryPayload(value)) {
+        const id = registerFile(value);
+        return { $file: id };
+      }
+      if (Array.isArray(value)) {
+        return value.map((item) => replaceFiles(item));
+      }
+      if (value && typeof value === "object") {
+        const result = {};
+        Object.keys(value).forEach((key) => {
+          result[key] = replaceFiles(value[key]);
+        });
+        return result;
+      }
+      return value;
+    };
+    const payload = replaceFiles(topic.body);
+    let offset = 0;
+    const files = fileEntries.map((entry) => {
+      const size = entry.buffer.length;
+      const meta2 = {
+        id: entry.id,
+        name: entry.name,
+        mime: entry.mime,
+        size,
+        offset
+      };
+      offset += size;
+      return meta2;
+    });
+    const meta = { ...topic, body: payload, files };
+    const json = Buffer.from(JSON.stringify(meta), "utf8");
+    const header = Buffer.alloc(4);
+    header.writeUInt32LE(json.length, 0);
+    const buffers = [header, json, ...fileEntries.map((entry) => entry.buffer)];
+    return Buffer.concat(buffers);
+  }
+  sendTopic(wsSet, topic) {
+    if (this.hasBinaryPayload(topic?.body)) {
+      const buffer = this.buildBinaryTopic(topic);
+      wsSet.socket.send(buffer, { binary: true });
+      return;
+    }
+    wsSet.socket.send(JSON.stringify(topic), { binary: false });
+  }
+  parseBinaryTopic(data) {
+    let buffer;
+    if (Buffer.isBuffer(data)) {
+      buffer = data;
+    } else if (data instanceof ArrayBuffer) {
+      buffer = Buffer.from(data);
+    } else if (Array.isArray(data)) {
+      buffer = Buffer.concat(data.map((item) => Buffer.isBuffer(item) ? item : Buffer.from(item)));
+    } else {
+      return void 0;
+    }
+    if (buffer.length < 4) {
+      return void 0;
+    }
+    const jsonLength = buffer.readUInt32LE(0);
+    const jsonStart = 4;
+    const jsonEnd = jsonStart + jsonLength;
+    if (buffer.length < jsonEnd) {
+      return void 0;
+    }
+    const jsonText = buffer.slice(jsonStart, jsonEnd).toString("utf8");
+    let meta;
+    try {
+      meta = JSON.parse(jsonText);
+    } catch (error) {
+      console.warn("Invalid WebSocket binary payload:", error);
+      return void 0;
+    }
+    const filesMeta = Array.isArray(meta.files) ? meta.files : [];
+    const fileMap = /* @__PURE__ */ new Map();
+    filesMeta.forEach((file) => {
+      if (!file || typeof file.id !== "string" || typeof file.size !== "number" || typeof file.offset !== "number") {
+        return;
+      }
+      const start = jsonEnd + file.offset;
+      const end = start + file.size;
+      if (start < jsonEnd || end > buffer.length) {
+        return;
+      }
+      const slice = buffer.slice(start, end);
+      fileMap.set(file.id, {
+        name: file.name || "file",
+        mime: file.mime || "application/octet-stream",
+        size: file.size,
+        buffer: slice
+      });
+    });
+    const replaceFileRefs = (value) => {
+      if (value && typeof value === "object" && "$file" in value && typeof value.$file === "string") {
+        const file = fileMap.get(value.$file);
+        if (file) {
+          return file;
+        }
+      }
+      if (Array.isArray(value)) {
+        return value.map((item) => replaceFileRefs(item));
+      }
+      if (value && typeof value === "object") {
+        const result = {};
+        Object.keys(value).forEach((key) => {
+          result[key] = replaceFileRefs(value[key]);
+        });
+        return result;
+      }
+      return value;
+    };
+    const body = replaceFileRefs(meta.body);
+    return {
+      type: meta.type,
+      uuid: meta.uuid,
+      requestUUID: meta.requestUUID,
+      body
+    };
+  }
+  message(wsSet, data) {
+    let topic;
+    if (data.isBinary) {
+      topic = this.parseBinaryTopic(data.data);
+      if (!topic) {
+        return;
+      }
+    } else {
+      try {
+        topic = JSON.parse(data.data.toString());
+      } catch (error) {
+        console.warn("Invalid WebSocket payload:", error);
+        return;
+      }
+    }
+    this.subject.next(topic);
+    const uuid = topic.uuid;
+    if (topic.type === "subscribe") {
+      try {
+        this.setClientTopic(wsSet, topic.uuid, topic.target, topic.body);
+      } catch (err) {
+        const responseTopic = {
+          state: "error",
+          // type: topic.type,
+          target: topic.target,
+          uuid: topic.uuid,
+          body: { message: err.message || "Error subscribing topic" }
+        };
+        wsSet.socket.send(JSON.stringify(responseTopic), { binary: false });
+      }
+      return;
+    } else if (topic.type === "unsubscribe") {
+      this.removeClientByUUID(uuid);
+      return;
+    } else if (topic.type === "event") {
+      const subscriptions = this.eventSubscriptions.get(topic.uuid);
+      if (subscriptions) {
+        const eventCallback = subscriptions.get(topic.eventUUID);
+        if (eventCallback) {
+          eventCallback(topic.body, wsSet);
+          subscriptions.delete(topic.eventUUID);
+        }
+        if (subscriptions.size <= 0) {
+          this.eventSubscriptions.delete(topic.uuid);
+        }
+      }
+      return;
+    } else {
+      const clientTopics = this.findClientByUUID(uuid);
+      if (!clientTopics) {
+        const responseTopic = {
+          state: "error",
+          uuid: topic.uuid,
+          requestUUID: topic.requestUUID,
+          target: "",
+          body: { message: "WebSocket client not registered" }
+        };
+        this.sendTopic(wsSet, responseTopic);
+        return;
+      }
+      const intent = new Intent(clientTopics.target);
+      const webSocketRequest = {
+        webSocketSet: wsSet,
+        uuid: clientTopics.uuid,
+        webSocketManager: this,
+        sendEvent: (event, body, config) => this.sendEventDataByUUIDPromise({ uuid: clientTopics.uuid, event, body }, config)
+      };
+      intent.data = [topic.body, webSocketRequest];
+      if (topic.type === "intent") {
+        this.intentManager.publishMeta(intent).then(async (it) => {
+          if (it.target.length <= 0) {
+            const responseTopic = {
+              state: "error",
+              // type: topic.type,
+              target: clientTopics.target,
+              uuid: topic.uuid,
+              requestUUID: topic.requestUUID,
+              body: { message: "Not found intent target" }
+            };
+            this.sendTopic(wsSet, responseTopic);
+          } else {
+            const rdata = it.return[0];
+            const wdata = rdata instanceof Promise ? await rdata : rdata;
+            const responseTopic = {
+              state: "success",
+              uuid: topic.uuid,
+              requestUUID: topic.requestUUID,
+              target: clientTopics.target,
+              body: wdata
+            };
+            this.sendTopic(wsSet, responseTopic);
+          }
+        });
+      } else if (topic.type === "router") {
+        this.routerManager.routing(intent).then(async (routerModule) => {
+          const moduleInstance = routerModule.getModuleInstance?.();
+          if (routerModule && moduleInstance) {
+            if (routerModule.propertyKeys) {
+              for (const it of routerModule.propertyKeys) {
+                let r = moduleInstance[it]?.(topic.body, webSocketRequest);
+                r = r instanceof Promise ? await r : r;
+                const responseTopic = {
+                  state: "success",
+                  requestUUID: topic.requestUUID,
+                  uuid: topic.uuid,
+                  target: clientTopics.target,
+                  body: r
+                };
+                this.sendTopic(wsSet, responseTopic);
+              }
+            } else {
+              const responseTopic = {
+                state: "error",
+                uuid: topic.uuid,
+                requestUUID: topic.requestUUID,
+                target: clientTopics.target,
+                body: { message: "Not found router target" }
+              };
+              this.sendTopic(wsSet, responseTopic);
+            }
+          } else {
+            const responseTopic = {
+              state: "error",
+              uuid: topic.uuid,
+              requestUUID: topic.requestUUID,
+              target: clientTopics.target,
+              body: { message: "Not found router target" }
+            };
+            this.sendTopic(wsSet, responseTopic);
+          }
+        });
+      }
+    }
+  }
+  removeAllClientsByWebSocketSet(wsSet) {
+    const topics = this.clients.get(wsSet);
+    if (!topics) {
+      return;
+    }
+    for (const topic of topics) {
+      this.eventSubscriptions.delete(topic.uuid);
+    }
+    this.clients.set(wsSet, []);
+  }
+};
+WebSocketManager = __decorate([
+  Sim,
+  __metadata("design:paramtypes", [typeof (_a = typeof IntentManager !== "undefined" && IntentManager) === "function" ? _a : Object, typeof (_b = typeof RouterManager !== "undefined" && RouterManager) === "function" ? _b : Object])
+], WebSocketManager);
+export {
+  WebSocketManager,
+  isTopicRequest,
+  isTopicResponse,
+  isTopicServerEventRequest,
+  isTopicServerEventResponse,
+  isTopicServerEventUnSubscribeRequest,
+  isTopicSubscribeRequest,
+  isTopicUnsubscribeRequest
+};
+//# sourceMappingURL=WebSocketManager.js.map