feat: messageType and spaceId

src/core/components/subscription_manager.js

@@ -581,6 +581,15 @@ export default class {
         if (message.userMetadata) {
           announce.userMetadata = message.userMetadata;
         }
+        if (message.type) {
+          announce.messageType = message.type;
+        } else {
+          announce.messageType = 'pn_signal';
+        }
+
+        if (message.spaceId) {
+          announce.spaceId = message.spaceId;
+        }
 
         announce.message = message.payload;
 
@@ -608,6 +617,8 @@ export default class {
           data: message.payload.data,
         };
 
+        announce.messageType = 'pn_object';
+
         this._listenerManager.announceObjects(announce);
 
         if (message.payload.type === 'uuid') {
@@ -662,6 +673,8 @@ export default class {
 
         announce.event = message.payload.event;
 
+        announce.messageType = 'pn_messageAction';
+
         this._listenerManager.announceMessageAction(announce);
       } else if (message.messageType === 4) {
         // this is a file message
@@ -697,6 +710,16 @@ export default class {
           }),
         };
 
+        if (message.type) {
+          announce.messageType = message.type;
+        } else {
+          announce.messageType = 'pn_file';
+        }
+
+        if (message.spaceId) {
+          announce.spaceId = message.spaceId;
+        }
+
         this._listenerManager.announceFile(announce);
       } else {
         const announce = {};
@@ -723,6 +746,16 @@ export default class {
           announce.message = message.payload;
         }
 
+        if (message.type) {
+          announce.messageType = message.type;
+        } else {
+          announce.messageType = 'pn_message';
+        }
+
+        if (message.spaceId) {
+          announce.spaceId = message.spaceId;
+        }
+
         this._listenerManager.announceMessage(announce);
       }
     });

src/core/endpoints/fetch_messages.js

@@ -1,12 +1,3 @@
-/*       */
-
-import {
-  FetchMessagesArguments,
-  FetchMessagesResponse,
-  MessageAnnouncement,
-  HistoryV3Response,
-  ModulesInject,
-} from '../flow_interfaces';
 import operationConstants from '../constants/operations';
 import utils from '../utils';
 
@@ -21,6 +12,21 @@ function __processMessage(modules, message) {
   }
 }
 
+function __getPNMessageTypeString(messageTypeInt) {
+  switch (messageTypeInt) {
+    case 0:
+      return 'pn_message';
+    case 3:
+      return 'pn_messageAction';
+    case 4:
+      return 'pn_file';
+    case null:
+      return 'pn_message';
+    default:
+      return `${messageTypeInt}`;
+  }
+}
+
 export function getOperation() {
   return operationConstants.PNFetchMessagesOperation;
 }
@@ -69,9 +75,11 @@ export function prepareParams(modules, incomingParams) {
     includeUuid,
     includeUUID = true,
     includeMessageType = true,
+    includeSpaceId = false,
   } = incomingParams;
   const outgoingParams = {};
-
+  outgoingParams.include_message_type = 'true';
+  outgoingParams.include_type = 'true';
   if (count) {
     outgoingParams.max = count;
   } else {
@@ -82,7 +90,11 @@ export function prepareParams(modules, incomingParams) {
   if (stringifiedTimeToken) outgoingParams.string_message_token = 'true';
   if (includeMeta) outgoingParams.include_meta = 'true';
   if (includeUUID && includeUuid !== false) outgoingParams.include_uuid = 'true';
-  if (includeMessageType) outgoingParams.include_message_type = 'true';
+  if (!includeMessageType) {
+    outgoingParams.include_message_type = 'false';
+    outgoingParams.include_type = 'false';
+  }
+  if (includeSpaceId) outgoingParams.include_space_id = 'true';
 
   return outgoingParams;
 }
@@ -100,7 +112,6 @@ export function handleResponse(modules, serverResponse) {
       announce.channel = channelName;
       announce.timetoken = messageEnvelope.timetoken;
       announce.message = __processMessage(modules, messageEnvelope.message);
-      announce.messageType = messageEnvelope.message_type;
       announce.uuid = messageEnvelope.uuid;
 
       if (messageEnvelope.actions) {
@@ -112,6 +123,13 @@ export function handleResponse(modules, serverResponse) {
       if (messageEnvelope.meta) {
         announce.meta = messageEnvelope.meta;
       }
+      if (typeof messageEnvelope.message_type != 'undefined' || messageEnvelope.type) {
+        announce.messageType = messageEnvelope.type || __getPNMessageTypeString(messageEnvelope.message_type);
+      }
+
+      if (messageEnvelope.space_id) {
+        announce.spaceId = messageEnvelope.space_id;
+      }
 
       response.channels[channelName].push(announce);
     });

src/core/endpoints/file_upload/publish_file.js

@@ -1,5 +1,3 @@
-/**       */
-
 import operationConstants from '../../constants/operations';
 
 import utils from '../../utils';
@@ -69,6 +67,14 @@ const endpoint = {
       outParams.meta = JSON.stringify(params.meta);
     }
 
+    if (params.spaceId) {
+      outParams['space-id'] = params.spaceId;
+    }
+
+    if (params.messageType) {
+      outParams.type = params.messageType;
+    }
+
     return outParams;
   },
 

src/core/endpoints/file_upload/send_file.js

@@ -18,7 +18,7 @@ const sendFile = function ({
   publishFile,
   modules: { PubNubFile, config, cryptography, networking },
 }) {
-  return async ({ channel, file: input, message, cipherKey, meta, ttl, storeInHistory }) => {
+  return async ({ channel, file: input, message, cipherKey, meta, ttl, storeInHistory, messageType, spaceId }) => {
     if (!channel) {
       throw new PubNubError(
         'Validation failed, check status for details',
@@ -99,6 +99,8 @@ const sendFile = function ({
           meta,
           storeInHistory,
           ttl,
+          messageType: messageType,
+          spaceId: spaceId,
         });
 
         wasSuccessful = true;

src/core/endpoints/publish.js

@@ -62,7 +62,7 @@ export function postPayload(modules, incomingParams) {
 }
 
 export function prepareParams(modules, incomingParams) {
-  const { meta, replicate = true, storeInHistory, ttl } = incomingParams;
+  const { meta, replicate = true, storeInHistory, ttl, spaceId, messageType } = incomingParams;
   const params = {};
 
   if (storeInHistory != null) {
@@ -85,6 +85,14 @@ export function prepareParams(modules, incomingParams) {
     params.meta = JSON.stringify(meta);
   }
 
+  if (messageType) {
+    params.type = messageType;
+  }
+
+  if (spaceId) {
+    params['space-id'] = spaceId;
+  }
+
   return params;
 }
 

src/core/endpoints/signal.js

@@ -39,9 +39,17 @@ export function isAuthSupported() {
   return true;
 }
 
-export function prepareParams() {
+export function prepareParams(_, incomingParams) {
+  const { spaceId, messageType } = incomingParams;
   const params = {};
 
+  if (messageType) {
+    params.type = messageType;
+  }
+
+  if (spaceId) {
+    params['space-id'] = spaceId;
+  }
   return params;
 }
 

src/core/endpoints/subscribe.js

@@ -1,13 +1,3 @@
-/*       */
-
-import {
-  SubscribeArguments,
-  PublishMetaData,
-  SubscribeMetadata,
-  SubscribeMessage,
-  SubscribeEnvelope,
-  ModulesInject,
-} from '../flow_interfaces';
 import operationConstants from '../constants/operations';
 import utils from '../utils';
 
@@ -84,6 +74,8 @@ export function handleResponse(modules, serverResponse) {
       subscribeKey: rawMessage.k,
       originationTimetoken: rawMessage.o,
       userMetadata: rawMessage.u,
+      type: rawMessage.mt,
+      spaceId: rawMessage.si,
       publishMetaData,
     };
     messages.push(parsedMessage);

test/contract/steps/files/files-vsf.ts

@@ -0,0 +1,22 @@
+import { When } from '@cucumber/cucumber';
+
+When('I send a file with {string} space id and {string} message type', async function (testSpaceId, testMessageType) {
+  const pubnub = this.getPubnub({
+    publishKey: this.keyset.publishKey,
+    subscribeKey: this.keyset.subscribeKey,
+  });
+
+  const testContent = `dummytext`;
+  try {
+    const response = await pubnub.sendFile({
+      channel: 'filestest',
+      file: { data: Buffer.from(testContent), name: 'myFile.txt', mimeType: 'text/plain' },
+      message: { text: 'fileMessage' },
+      spaceId: testSpaceId,
+      messageType: testMessageType,
+    });
+    this.isSucceed = response.timetoken === '1';
+  } catch (e) {
+    this.isSucceed = false;
+  }
+});

test/contract/steps/history/fetchMessages.ts

@@ -0,0 +1,64 @@
+import { Given, When, Then } from '@cucumber/cucumber';
+import { expect } from 'chai';
+
+Given('the demo keyset with enabled storage', function () {
+  this.keyset = this.fixtures.demoKeyset;
+});
+
+When('I fetch message history for {string} channel', async function (testChannel) {
+  const pubnub = this.getPubnub({
+    publishKey: this.keyset.publishKey,
+    subscribeKey: this.keyset.subscribeKey,
+  });
+
+  const response = await pubnub.fetchMessages({
+    channels: [testChannel],
+  });
+
+  this.isSucceed = true;
+  this.historyMessages = response.channels[testChannel];
+});
+
+When(
+  'I fetch message history with {string} set to {string} for {string} channel',
+  async function (param, paramValue, channel) {
+    const pubnub = this.getPubnub({
+      publishKey: this.keyset.publishKey,
+      subscribeKey: this.keyset.subscribeKey,
+    });
+
+    const request = {
+      channels: [channel],
+    };
+    request[param] = paramValue === 'true' ? true : false;
+
+    const response = await pubnub.fetchMessages(request);
+
+    this.isSucceed = true;
+    this.historyMessages = response.channels[channel];
+  },
+);
+
+Then(
+  'history response contains messages with {string} and {string} message types',
+  function (firstMessageType, secondMessageType) {
+    expect(this.historyMessages.filter((m) => m.messageType === firstMessageType)).to.have.lengthOf(1);
+    expect(this.historyMessages.filter((m) => m.messageType === secondMessageType)).to.have.lengthOf(1);
+  },
+);
+
+Then('history response contains messages without space ids', function () {
+  this.historyMessages.forEach((m) => expect(m).to.not.have.property('spaceId'));
+});
+
+Then('history response contains messages with space ids', function () {
+  this.historyMessages.forEach((m) => expect(m).to.have.property('spaceId'));
+});
+
+Then('history response contains messages with message types', function () {
+  this.historyMessages.forEach((m) => expect(m).to.have.property('messageType'));
+});
+
+Then('history response contains messages without message types', function () {
+  this.historyMessages.forEach((m) => expect(m).to.not.have.property('messageType'));
+});

test/contract/steps/objectsv2/uuid.ts

@@ -90,6 +90,7 @@ When('I get all UUID metadata with custom', async function () {
   });
 
   this.response = await pubnub.objects.getAllUUIDMetadata({ include: { customFields: true } });
+  this.isSucceed = this.response.status === 200;
 });
 
 Then('the UUID metadata for {string} persona', async function (persona) {
@@ -105,7 +106,7 @@ Then('the UUID metadata for {string} persona contains updated', async function (
 });
 
 Then('I receive a successful response', function () {
-  expect(this.response.status).to.equal(200);
+  expect(this.isSucceed).to.be.true;
 });
 
 Then('the response contains list with {string} and {string} UUID metadata', function (firstPersona, secondPersona) {

test/contract/steps/publish/publishToSpace.ts

@@ -0,0 +1,28 @@
+import { When, Then } from '@cucumber/cucumber';
+import { expect } from 'chai';
+
+When('I publish message with {string} space id and {string} message type', async function (spaceId, messageType) {
+  const pubnub = this.getPubnub({
+    publishKey: this.keyset.publishKey,
+    subscribeKey: this.keyset.subscribeKey,
+  });
+
+  try {
+    const response = await pubnub.publish({
+      channel: 'test',
+      message: { hello: 'world' },
+      spaceId: spaceId,
+      messageType: messageType,
+    });
+
+    this.isSucceed = typeof response.timetoken === 'string';
+  } catch (status) {
+    if ((status as { error: boolean }).error) {
+      this.isSucceed = false;
+    }
+  }
+});
+
+Then('I receive an error response', function () {
+  expect(this.isSucceed).to.be.false;
+});