@service-broker/webclient 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Service Broker
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,2 @@
+# service-broker-webclient
+Browser JavaScript library for communicating with the service broker

package/dist/index.d.ts

@@ -0,0 +1,34 @@
+
+interface ServiceFilter {
+  name: string
+  capabilities?: string[]
+}
+
+export interface ServiceAdvert {
+  name: string
+  capabilities?: string[]
+  priority: number
+}
+
+export interface ServiceHandler {
+  (msg: Message): Partial<Message>|void|Promise<Partial<Message>|void>
+}
+
+interface Message {
+  header: any
+  payload: any
+}
+
+declare class ServiceBroker {
+  constructor(url: string, logger: {error: Console["error"], debug: Console["debug"]});
+  request<T>(service: ServiceFilter, req: unknown): Promise<T>;
+  requestTo<T>(endpointId: string, service: ServiceFilter, req: unknown): Promise<T>;
+  advertise(service: ServiceAdvert, handler: ServiceHandler): Promise<void>;
+  unadvertise(serviceName: string): Promise<void>;
+  setHandler(serviceName: string, handler: ServiceHandler): void;
+  publish(topic: string, text: string): Promise<void>;
+  subscribe(topic: string, handler: (text: string) => void): Promise<void>;
+  unsubscribe(topic: string): Promise<void>;
+  isConnected(): boolean;
+  addConnectListener(listener: () => void): void;
+}

package/dist/index.js

@@ -0,0 +1,184 @@
+exports.ServiceBroker = ServiceBroker;
+
+function ServiceBroker(url, logger) {
+  var pending = {};
+  var pendingIdGen = 0;
+  var providers = {};
+  var ws;
+  var connectListeners = [];
+  var pendingSend = [];
+  connect();
+
+  function connect() {
+    var conn = new WebSocket(url);
+    conn.onopen = onOpen.bind(null, conn);
+    conn.onerror = function() {
+      logger.error("Failed to connect to service broker, retrying in 15");
+      setTimeout(connect, 15000);
+    };
+  }
+
+  function onOpen(conn) {
+    ws = conn;
+    ws.onerror = logger.error;
+    ws.onclose = onClose;
+    ws.onmessage = onMessage;
+    for (var i=0; i<connectListeners.length; i++) connectListeners[i]();
+    for (var i=0; i<pendingSend.length; i++) send(pendingSend[i].header, pendingSend[i].payload);
+    pendingSend = [];
+  }
+
+  function onClose() {
+    ws = null;
+    logger.error("Lost connection to service broker, reconnecting");
+    setTimeout(connect, 0);
+  }
+
+  function onMessage(e) {
+    var msg = messageFromString(e.data);
+    logger.debug("<<", msg.header, msg.payload);
+    if (msg.header.type == "ServiceResponse") onServiceResponse(msg);
+    else if (msg.header.type == "ServiceRequest") onServiceRequest(msg);
+    else if (msg.header.type == "SbStatusResponse") onServiceResponse(msg);
+    else if (msg.header.error) onServiceResponse(msg);
+    else logger.error("Unhandled", msg.header);
+  }
+
+  function messageFromString(text) {
+    var index = text.indexOf('\n');
+    if (index == -1) return {header: JSON.parse(text)};
+    else return {header: JSON.parse(text.substr(0,index)), payload: text.substr(index+1)};
+  }
+
+  function onServiceResponse(msg) {
+    if (pending[msg.header.id]) {
+      if (msg.header.error) pending[msg.header.id].reject(new Error(msg.header.error));
+      else pending[msg.header.id].fulfill(msg);
+      delete pending[msg.header.id];
+    }
+    else logger.error("Response received but no pending request", msg.header);
+  }
+
+  function onServiceRequest(msg) {
+    if (providers[msg.header.service.name]) {
+      Promise.resolve(providers[msg.header.service.name].handler(msg))
+        .then(function(res) {
+          if (!res) res = {};
+          if (msg.header.id) {
+            var header = {
+              to: msg.header.from,
+              id: msg.header.id,
+              type: "ServiceResponse"
+            };
+            send(Object.assign({}, res.header, header), res.payload);
+          }
+        })
+        .catch(function(err) {
+          if (msg.header.id) {
+            send({
+              to: msg.header.from,
+              id: msg.header.id,
+              type: "ServiceResponse",
+              error: err.message
+            })
+          }
+          else logger.error(err.message, msg.header);
+        })
+    }
+    else logger.error("No handler for service " + msg.header.service.name);
+  }
+
+
+
+  this.request = function(service, req) {
+    return this.requestTo(null, service, req);
+  }
+
+  this.requestTo = function(endpointId, service, req) {
+    var id = ++pendingIdGen;
+    var promise = new Promise(function(fulfill, reject) {
+      pending[id] = {fulfill: fulfill, reject: reject};
+    })
+    var header = {
+      id: id,
+      type: "ServiceRequest",
+      service: service
+    };
+    if (endpointId) header.to = endpointId;
+    send(Object.assign({}, req.header, header), req.payload);
+    return promise;
+  }
+
+  function send(header, payload) {
+      if (!ws) {
+        pendingSend.push({header: header, payload: payload});
+        return;
+      }
+      logger.debug(">>", header, payload);
+      ws.send(JSON.stringify(header) + (payload ? "\n"+payload : ""));
+  }
+
+
+
+  this.advertise = function(service, handler) {
+    if (providers[service.name]) throw new Error(service.name + " provider already exists");
+    providers[service.name] = {
+      advertisedService: service,
+      handler: handler
+    }
+    return send({
+      type: "SbAdvertiseRequest",
+      services: Object.keys(providers)
+        .map(function(x) {return providers[x].advertisedService})
+        .filter(function(x) {return x})
+    })
+  }
+
+  this.unadvertise = function(serviceName) {
+    if (!providers[serviceName]) throw new Error(serviceName + " provider not exists");
+    delete providers[serviceName];
+    return send({
+      type: "SbAdvertiseRequest",
+      services: Object.keys(providers)
+        .map(function(x) {return providers[x].advertisedService})
+        .filter(function(x) {return x})
+    })
+  }
+
+  this.setHandler = function(serviceName, handler) {
+    if (providers[serviceName]) throw new Error("Handler already exists");
+    providers[serviceName] = {
+      handler: handler
+    }
+  }
+
+
+
+  this.publish = function(topic, text) {
+    return send({
+      type: "ServiceRequest",
+      service: {name: "#"+topic}
+    },
+    text);
+  }
+
+  this.subscribe = function(topic, handler) {
+    return this.advertise({name: "#"+topic}, function(msg) {
+      handler(msg.payload);
+      return null;
+    })
+  }
+
+  this.unsubscribe = function(topic) {
+    return this.unadvertise("#"+topic);
+  }
+
+  this.isConnected = function() {
+    return ws != null;
+  }
+
+  this.addConnectListener = function(listener) {
+    connectListeners.push(listener);
+    if (this.isConnected()) listener();
+  }
+}

package/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@service-broker/webclient",
+  "version": "1.0.0",
+  "description": "Browser JavaScript library for communicating with the service broker",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/service-broker/service-broker-webclient.git"
+  },
+  "author": "Hai Phan <hai.phan@gmail.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/service-broker/service-broker-webclient/issues"
+  },
+  "homepage": "https://github.com/service-broker/service-broker-webclient#readme"
+}