@ndustrial/contxt-sdk 5.2.6 → 5.4.0

package/src/bus/channels.spec.js

@@ -344,4 +344,111 @@ describe('Bus/Channels', function() {
       });
     });
   });
+
+  describe('peek', function() {
+    context('the required fields are provided', function() {
+      let channelFromServerAfterFormat;
+      let channelFromServerBeforeFormat;
+      let expectedOrganizationId;
+      let expectedServiceId;
+      let expectedChannelId;
+      let expectedSubscription;
+      let promise;
+      let request;
+      let toCamelCase;
+
+      beforeEach(function() {
+        channelFromServerAfterFormat = fixture.build('channel');
+        expectedSubscription = "test";
+        expectedChannelId = channelFromServerAfterFormat.id;
+        expectedOrganizationId = channelFromServerAfterFormat.organizationId;
+        expectedServiceId = channelFromServerAfterFormat.serviceId;
+        channelFromServerBeforeFormat = fixture.build(
+          'channel',
+          channelFromServerAfterFormat,
+          { fromServer: true }
+        );
+
+        request = {
+          ...baseRequest,
+          get: sinon.stub().resolves(channelFromServerBeforeFormat)
+        };
+        toCamelCase = sinon
+          .stub(objectUtils, 'toCamelCase')
+          .returns(channelFromServerAfterFormat);
+
+        const channels = new Channels(baseSdk, request);
+        channels._baseUrl = expectedHost;
+
+        promise = channels.peek(
+          expectedOrganizationId,
+          expectedServiceId,
+          expectedChannelId,
+          expectedSubscription
+        );
+      });
+
+      it('gets the channel from the server', function() {
+        expect(request.get).to.be.calledWith(
+          `${expectedHost}/organizations/${expectedOrganizationId}/services/${expectedServiceId}/channels/${expectedChannelId}/peek/${expectedSubscription}`
+        );
+      });
+
+      it('formats the channel object', function() {
+        return promise.then(() => {
+          expect(toCamelCase).to.be.calledWith(channelFromServerBeforeFormat);
+        });
+      });
+
+      it('returns the requested event', function() {
+        return expect(promise).to.be.fulfilled.and.to.eventually.deep.equal(
+          channelFromServerAfterFormat
+        );
+      });
+    });
+
+    context('the organizationId is not provided', function() {
+      it('throws an error', function() {
+        const channels = new Channels(baseSdk, baseRequest);
+        const promise = channels.peek();
+
+        return expect(promise).to.be.rejectedWith(
+          'An organizationId is required to peek a message bus channel subscription.'
+        );
+      });
+    });
+
+    context('the serviceId is not provided', function() {
+      it('throws an error', function() {
+        const channels = new Channels(baseSdk, baseRequest);
+        const promise = channels.peek('1');
+
+        return expect(promise).to.be.rejectedWith(
+          'A serviceId is required to peek a message bus channel subscription.'
+        );
+      });
+    });
+
+    context('the channelId is not provided', function() {
+      it('throws an error', function() {
+        const channels = new Channels(baseSdk, baseRequest);
+        const promise = channels.peek('1', '2');
+
+        return expect(promise).to.be.rejectedWith(
+          'A channelId is required to peek a message bus channel subscription.'
+        );
+      });
+    });
+
+    context('the subscription is not provided', function() {
+      it('throws an error', function() {
+        const channels = new Channels(baseSdk, baseRequest);
+        const promise = channels.peek('1', '2', '3');
+
+        return expect(promise).to.be.rejectedWith(
+          'A subscription name is required to peek a message bus channel subscription.'
+        );
+      });
+    });
+  });
 });

package/src/bus/index.js

@@ -35,6 +35,20 @@ import WebSocketConnection from './webSocketConnection';
  * @property {WebSocket} _webSocket The raw WebSocket connection to the message bus
  */
 
+/**
+ * Configuration object for the Bus
+ *
+ * @typedef {Object} BusConfig
+ * @property {boolean} autoAcknowledge
+ */
+
+/**
+ * @type {BusConfig}
+ */
+const defaultBusConfig = {
+  autoAcknowledge: true
+};
+
 /**
  * Module that provides access to the message bus. This is for Node
  * environments. Documentation for browser environments is found under
@@ -46,8 +60,9 @@ class Bus {
   /**
    * @param {Object} sdk An instance of the SDK so the module can communicate with other modules
    * @param {Object} request An instance of the request module tied to this module's audience.
+   * @param {BusConfig} config A config object for the Bus instance
    */
-  constructor(sdk, request) {
+  constructor(sdk, request, config) {
     const baseUrl = `${sdk.config.audiences.bus.host}`;
     const baseWebSocketUrl = `${sdk.config.audiences.bus.webSocket}`;
 
@@ -56,6 +71,7 @@ class Bus {
     this._request = request;
     this._sdk = sdk;
     this._webSockets = {};
+    this._config = Object.assign({}, defaultBusConfig, config);
 
     this.channels = new Channels(sdk, request, baseUrl);
   }
@@ -101,7 +117,8 @@ class Bus {
           ws.onopen = (event) => {
             this._webSockets[organizationId] = new WebSocketConnection(
               ws,
-              organizationId
+              organizationId,
+              this._config.autoAcknowledge
             );
 
             resolve(this._webSockets[organizationId]);

package/src/bus/index.spec.js

@@ -290,6 +290,48 @@ describe('Bus', function() {
         );
       }
     );
+
+    context('when providing custom config', function() {
+      let bus;
+      let expectedApiToken;
+      let promise;
+      let sdk;
+      let server;
+      let busConfig
+
+      beforeEach(function() {
+        expectedApiToken = faker.internet.password();
+
+        sdk = {
+          ...baseSdk,
+          auth: {
+            ...baseSdk.auth,
+            getCurrentApiToken: sinon.stub().resolves(expectedApiToken)
+          }
+        };
+
+        server = new Server(
+          `${expectedHost}/organizations/${expectedOrganization.id}/stream`
+        );
+
+        busConfig = { autoAcknowledge: false };
+        bus = new Bus(sdk, baseRequest, busConfig);
+        bus._baseWebSocketUrl = expectedHost;
+
+        promise = bus.connect(expectedOrganization.id);
+      });
+
+      afterEach(function() {
+        server.stop();
+      });
+
+      it('passes the auto-acknowledge flag to the WebSocketConnection', function() {
+        return promise.then((resolvedWebSocket) => {
+          expect(resolvedWebSocket._autoAck).to.equal(busConfig.autoAcknowledge);
+        });
+      });
+
+    });
   });
 
   describe('getWebSocketConnection', function() {

package/src/bus/webSocketConnection.js

@@ -29,11 +29,13 @@ class WebSocketConnection {
   /**
    * @param {WebSocket} webSocket A WebSocket connection to the message bus
    * @param {string} organizationId UUID corresponding with an organization
+   * @param {boolean} autoAcknowledge Whether the messages should be ACK'd explicitly or not
    */
-  constructor(webSocket, organizationId) {
+  constructor(webSocket, organizationId, autoAcknowledge = true) {
     this._messageHandlers = {};
     this._organizationId = organizationId;
     this._webSocket = webSocket;
+    this._autoAck = autoAcknowledge;
 
     if (this._webSocket) {
       this._webSocket.onerror = this._onError;
@@ -282,20 +284,24 @@ class WebSocketConnection {
 
             if (error) {
               return resolve(errorHandler(error));
-            } else {
-              try {
-                const ack = once(() => {
-                  return this._acknowledge(result.id);
-                });
-
-                return resolve(
-                  Promise.resolve(handler(result.body, ack)).then((res) => {
+            }
+
+            try {
+              const ack = once(() => {
+                return this._acknowledge(result.id);
+              });
+
+              return resolve(
+                Promise.resolve(handler(result.body, ack)).then((res) => {
+                  if (this._autoAck) {
                     return ack().then(() => res);
-                  })
-                );
-              } catch (throwable) {
-                return reject(throwable);
-              }
+                  }
+
+                  return res;
+                })
+              );
+            } catch (throwable) {
+              return reject(throwable);
             }
           });
         };

package/src/bus/webSocketConnection.spec.js

@@ -1755,6 +1755,51 @@ describe('Bus/WebSocketConnection', function() {
               });
           });
         });
+
+        context('and the client does not auto-ack', function() {
+          let errorHandler;
+
+          beforeEach(function() {
+            handler = sinon.stub().returns(null);
+            errorHandler = sinon.stub().returns(null);
+
+            ws = new WebSocketConnection(
+              expectedWebSocket,
+              expectedOrganization.id,
+              false
+            );
+
+            promise = ws.subscribe(
+              serviceId,
+              channel,
+              group,
+              handler,
+              errorHandler
+            );
+
+            jsonRpcId = Object.keys(ws._messageHandlers)[0];
+
+            ws._messageHandlers[jsonRpcId]({
+              result: {
+                subscription
+              }
+            });
+          });
+
+          it('doesn\'t call the ack function', function() {
+            return promise
+              .then(() => {
+                return ws._messageHandlers[subscription]({
+                  result: {
+                    error: message
+                  }
+                });
+              })
+              .catch(() => {
+                expect(acknowledge).to.not.be.called;
+              });
+          });
+        });
       });
 
       context('without a group', function() {

package/src/config/defaults.js

@@ -7,5 +7,8 @@ export default {
   interceptors: {
     request: [],
     response: []
+  },
+  bus: {
+    autoAcknowledge: true
   }
 };

package/src/config/index.js

@@ -116,6 +116,11 @@ class Config {
       ...defaultConfigs.interceptors,
       ...userConfig.interceptors
     };
+
+    this.bus = {
+      ...defaultConfigs.bus,
+      ...userConfig.bus
+    };
   }
 
   addDynamicAudience(audienceName, { clientId, host }) {

package/src/index.js

@@ -78,7 +78,7 @@ class ContxtSdk {
     this.config = new Config(config, externalModules);
 
     this.auth = this._createAuthSession(sessionType);
-    this.bus = new Bus(this, this._createRequest('bus'));
+    this.bus = new Bus(this, this._createRequest('bus'), this.config.bus);
     this.coordinator = new Coordinator(
       this,
       this._createRequest('coordinator')

package/src/index.spec.js

@@ -76,6 +76,15 @@ describe('ContxtSdk', function() {
       expect(contxtSdk.bus).to.be.an.instanceof(Bus);
     });
 
+    it('passes bus config to the bus constructor', function() {
+      contxtSdk = new ContxtSdk({
+        config: {...baseConfig, bus: {autoAcknowledge: false}},
+        externalModules: expectedExternalModules,
+        sessionType: expectedAuthSessionType
+      });
+      expect(contxtSdk.bus._config).to.deep.equal({autoAcknowledge: false});
+    });
+
     it('sets an instance of Config', function() {
       expect(contxtSdk.config).to.be.an.instanceof(Config);
     });