- Websocket events in non-websocket services

- Support multiple endpoints

Author: oklemenz2

CHANGELOG.md

@@ -5,6 +5,13 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
+## Version 0.1.1 - 22.12.23
+
+### Added
+
+- Websocket events in non-websocket services
+- Support multiple endpoints
+
 ## Version 0.1.0 - 21.12.23
 
 ### Added

README.md

@@ -91,7 +91,25 @@ Valid UAA bindings for approuter and backend are necessary, so that the authoriz
 Locally, the following default environment files need to exist:
 
 - `test/\_env/default-env.json`
+  ```
+  {
+    "VCAP_SERVICES": {
+      "xsuaa": [
+        {
+          ...
+        }
+      ]
+    }
+  }
+  ```
 - `test/\_env/approuter/default-services.json`
+  ```
+  {
+    "uaa": {
+      ...
+    }
+  }
+  ```
 
 Approuter is configured to support websockets in `xs-app.json` according to [@sap/approuter - websockets property](https://www.npmjs.com/package/@sap/approuter#websockets-property):
 

package-lock.json

@@ -27,12 +27,56 @@ function serveWebSocketServer(options) {
   cds.on("listening", (app) => {
     socketServer = initWebSocketServer(app.server, options.path);
     if (socketServer) {
+      // Websocket services
       for (const serviceName in options.services) {
         const service = options.services[serviceName];
         if (isServedViaWebsocket(service)) {
           serveWebSocketService(socketServer, service, options);
         }
       }
+      // Websockets events
+      const eventServices = {};
+      for (const name in cds.model.definitions) {
+        const definition = cds.model.definitions[name];
+        if (definition.kind === "event" && (definition["@websocket"] || definition["@ws"])) {
+          const service = cds.services[definition._service?.name];
+          if (service && !isServedViaWebsocket(service)) {
+            eventServices[service.name] ??= eventServices[service.name] || {
+              name: service.name,
+              definition: service.definition,
+              endpoints: service.endpoints.map((endpoint) => {
+                const protocol =
+                  cds.env.protocols[endpoint.kind] ||
+                  (endpoint.kind === "odata" ? cds.env.protocols["odata-v4"] : null);
+                return {
+                  kind: "websocket",
+                  path: cds.env.protocols.websocket.path + normalizeServicePath(service.path, protocol.path),
+                };
+              }),
+              operations: () => {
+                return [];
+              },
+              entities: () => {
+                return [];
+              },
+              events: [],
+              on: service.on.bind(service),
+              tx: service.tx.bind(service),
+            };
+            eventServices[service.name].events.push(definition);
+          }
+        }
+      }
+      for (const name in eventServices) {
+        const eventService = eventServices[name];
+        const events = eventService.events;
+        if (events.length > 0) {
+          eventService.events = () => {
+            return events;
+          };
+          serveWebSocketService(socketServer, eventService, options);
+        }
+      }
     }
   });
 }
@@ -51,27 +95,35 @@ function initWebSocketServer(server, path) {
   }
 }
 
-function serveWebSocketService(socketServer, service, options) {
-  let servicePath = service.path;
-  if (servicePath.startsWith(options.path)) {
-    servicePath = servicePath.substring(options.path.length);
+function normalizeServicePath(servicePath, protocolPath) {
+  if (servicePath.startsWith(protocolPath)) {
+    return servicePath.substring(protocolPath.length);
   }
-  try {
-    socketServer.service(servicePath, (socket) => {
+  return servicePath;
+}
+
+function serveWebSocketService(socketServer, service, options) {
+  for (const endpoint of service.endpoints || []) {
+    if (["websocket", "ws"].includes(endpoint.kind)) {
+      const servicePath = normalizeServicePath(endpoint.path, options.path);
       try {
-        socket.setup();
-        emitConnect(socket, service);
-        bindServiceDefaults(socket, service);
-        bindServiceOperations(socket, service);
-        bindServiceEntities(socket, service);
-        bindServiceEvents(socket, service);
+        socketServer.service(servicePath, (socket) => {
+          try {
+            socket.setup();
+            emitConnect(socket, service);
+            bindServiceDefaults(socket, service);
+            bindServiceOperations(socket, service);
+            bindServiceEntities(socket, service);
+            bindServiceEvents(socket, service);
+          } catch (err) {
+            LOG?.error(err);
+            socket.disconnect();
+          }
+        });
       } catch (err) {
         LOG?.error(err);
-        socket.disconnect();
       }
-    });
-  } catch (err) {
-    LOG?.error(err);
+    }
   }
 }
 
@@ -247,7 +299,13 @@ function serviceLocalName(service, name) {
 }
 
 function isServedViaWebsocket(service) {
+  if (!service) {
+    return false;
+  }
   const serviceDefinition = service.definition;
+  if (!serviceDefinition) {
+    return false;
+  }
   let protocols = serviceDefinition["@protocol"];
   if (protocols) {
     protocols = !Array.isArray(protocols) ? [protocols] : protocols;

src/index.js

@@ -0,0 +1,10 @@
+"use strict";
+
+module.exports = (srv) => {
+  const { Header } = srv.entities();
+
+  srv.before("CREATE", Header, async (req) => {
+    srv.emit("received", req.data);
+    srv.emit("receivedToo", req.data);
+  });
+};

test/_env/srv/handlers/odata.js

@@ -6,5 +6,15 @@ service ODataService {
     entity Header as projection on test.Header;
 
     function message(text: String) returns String;
+
+    @ws
+    event received {
+        text: String;
+    }
+
+    @websocket
+    event receivedToo {
+        text: String;
+    }
 }
 

test/_env/srv/odata.cds

@@ -0,0 +1,43 @@
+"use strict";
+
+const cds = require("@sap/cds");
+
+const { connect, disconnect, emitEvent, waitForEvent } = require("./_env/util/socketio");
+const { authorization } = require("./_env/util/common");
+
+cds.test(__dirname + "/_env");
+
+cds.env.requires.websocket = {
+  kind: "socket.io",
+};
+
+describe("OData", () => {
+  let socket;
+  let service;
+
+  beforeAll(async () => {
+    socket = await connect("odata");
+    service = await cds.connect.to("TodoService");
+  });
+
+  afterAll(() => {
+    disconnect(socket);
+  });
+
+  test("Event", async () => {
+    const waitReceivedPromise = waitForEvent(socket, "received");
+    const waitReceivedTooPromise = waitForEvent(socket, "receivedToo");
+    const response = await fetch(cds.server.url + "/odata/v4/odata/Header", {
+      method: "POST",
+      headers: { "content-type": "application/json", authorization },
+      body: JSON.stringify({ name: "Test" }),
+    });
+    const result = await response.json();
+    expect(result.ID).toBeDefined();
+    const ID = result.ID;
+    const waitResult = await waitReceivedPromise;
+    expect(waitResult).toMatchObject({});
+    const waitResultToo = await waitReceivedTooPromise;
+    expect(waitResultToo).toMatchObject({});
+  });
+});

test/odata_socketio.test.js

@@ -0,0 +1,39 @@
+"use strict";
+
+const cds = require("@sap/cds");
+
+const { connect, disconnect, emitEvent, waitForEvent } = require("./_env/util/ws");
+const { authorization } = require("./_env/util/common");
+
+cds.test(__dirname + "/_env");
+
+describe("OData", () => {
+  let socket;
+  let service;
+
+  beforeAll(async () => {
+    socket = await connect("/ws/odata");
+    service = await cds.connect.to("TodoService");
+  });
+
+  afterAll(() => {
+    disconnect(socket);
+  });
+
+  test("Event", async () => {
+    const waitReceivedPromise = waitForEvent(socket, "received");
+    const waitReceivedTooPromise = waitForEvent(socket, "receivedToo");
+    const response = await fetch(cds.server.url + "/odata/v4/odata/Header", {
+      method: "POST",
+      headers: { "content-type": "application/json", authorization },
+      body: JSON.stringify({ name: "Test" }),
+    });
+    const result = await response.json();
+    expect(result.ID).toBeDefined();
+    const ID = result.ID;
+    const waitResult = await waitReceivedPromise;
+    expect(waitResult).toMatchObject({});
+    const waitResultToo = await waitReceivedTooPromise;
+    expect(waitResultToo).toMatchObject({});
+  });
+});