@hubot-friends/hubot-slack 1.0.10 → 2.0.0

package/index.js

@@ -1,5 +1,5 @@
-const SlackBot = require('./src/bot');
-require('./src/extensions');
+const SlackBot = require('./src/bot.js').SlackBot;
+require('./src/extensions.js');
 
 exports.use = function(robot) {
   let e;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hubot-friends/hubot-slack",
-  "version": "1.0.10",
+  "version": "2.0.0",
   "description": "A new Slack adapter for Hubot",
   "homepage": "https://github.com/hubot-friends/hubot-slack#readme",
   "main": "./index.js",
@@ -27,7 +27,7 @@
     "@slack/web-api": "^6.8.1"
   },
   "peerDependencies": {
-    "hubot": ">= 7.0.0"
+    "hubot": ">= 9.0.0"
   },
   "engines": {
     "node": ">= 18.16.0",

package/src/SlackAdapter.mjs

@@ -264,15 +264,12 @@ class SlackAdapter extends Adapter {
         this.robot.logger.info(`Replying to message in ${envelope.room}`)
         return this.send(envelope, ...strings)
     }
-    run() {
-        this.#webSocketClient.start().then(async result => {
-            // const channelResponse = await this.#webClient.conversations.list()
-            // console.log('channelResponse', channelResponse)
-            const response = await this.#webClient.auth.test()
-            this.robot.self = new AuthTestResponse(response).user
-            this.robot.logger.info('Connected to Slack after starting socket client.')
-            this.emit('connected')
-        }).catch(e => this.robot.logger.error(e))
+    async run() {
+        await this.#webSocketClient.start()
+        const response = await this.#webClient.auth.test()
+        this.robot.self = new AuthTestResponse(response).user
+        this.robot.logger.info('Connected to Slack after starting socket client.')
+        this.emit('connected')
     }
 }
 

package/src/SlackAdapter.test.mjs

@@ -237,57 +237,60 @@ describe('Listen to messages', async () => {
                 adapter.emit('authenticated', authenticatedPerson(), null)
             }
         })
-        robot.run()
+        await robot.run()
     })
     afterEach(async () => {
         robot.shutdown()
     })
-    it('should listen to a message', (t, done) => {
+    it('should listen to a message', async () => {
+        let wasCalled = false
         robot.listen(message => {
             if(message instanceof TextMessage) {
                 assert.deepEqual(message.text, 'Hello world')
-                done()
+                wasCalled = true
                 return true
             }
             assert.fail('expect a message')
         },
         {id: 'message listener'},
-        res => {
-            res.send('hi')
+        async res => {
+            await res.send('hi')
             assert.ok(true, 'should be called for message')
         })
-        robot.adapter.mapToHubotMessage(buildSlackMessage({
+        const message = await robot.adapter.mapToHubotMessage(buildSlackMessage({
             "type": "message",
             "channel": "C123ABC456",
             "user": "U123ABC456",
             "text": "Hello world",
             "ts": "1355517523.000005"
-        }).event).then(message => {
-            robot.receive(message)
-        }).catch(e => console.error)
+        }).event)
+        await robot.receive(message)
+        assert.deepEqual(wasCalled, true)
     })
-    it('should hear a message, which uses regex for matching', (t, done) => {
+    it('should hear a message, which uses regex for matching', async () => {
+        let wasCalled = false
         robot.hear(/hello/i, {id: 'message listener'},
             context => {
                 assert.deepEqual(context.message.text, 'hello')
-                done()
+                wasCalled = true
                 return true
             }
         )
-        robot.adapter.mapToHubotMessage(buildSlackMessage({
+        const message = await robot.adapter.mapToHubotMessage(buildSlackMessage({
             "type": "message",
             "channel": "C123ABC456",
             "user": "U123ABC456",
             "text": `hello`,
             "ts": "1355517523.000005"
-        }).event).then(message => {
-            robot.receive(message)
-        }).catch(e =>console.error)
+        }).event)
+        await robot.receive(message)
+        assert.deepEqual(wasCalled, true)
     })
 })
 
 describe('Send messages back', async () => {
-    it('should reply to a message that was sent to Hubot', (t, done) => {
+    it('should reply to a message that was sent to Hubot', async () => {
+        let wasCalled = false
         const robot = makeRobot({
             async start(adapter) {
                 adapter.emit('authenticated', authenticatedPerson(), null)
@@ -297,8 +300,6 @@ describe('Send messages back', async () => {
                 async postMessage({ channel, text }) {
                     assert.deepEqual(channel, 'C123ABC456')
                     assert.deepEqual(text, 'hi')
-                    robot.shutdown()
-                    done()
                 }
             },
             users: {
@@ -317,26 +318,24 @@ describe('Send messages back', async () => {
                 }
             }
         })
-        robot.run()
-
         robot.respond(/hello/i, {id: 'message responder'},
             context => {
                 assert.deepEqual(context.message.text, '@hubot hello')
                 context.reply('hi')
-                done()
                 robot.shutdown()
+                wasCalled = true
             })
-        robot.adapter.on('connected', () => {
-            robot.adapter.mapToHubotMessage(buildSlackMessage({
-                "type": "message",
-                "channel": "C123ABC456",
-                "user": "U123ABC456",
-                "text": `<@${BOT_ID}> hello`,
-                "ts": "1355517523.000005"
-            }).event).then(message => {
-                message.text = robot.adapter.replaceBotIdWithName(message)
-                robot.receive(message)
-            }).catch(e => console.error)
-        })
+        await robot.run()
+        const message = await robot.adapter.mapToHubotMessage(buildSlackMessage({
+            "type": "message",
+            "channel": "C123ABC456",
+            "user": "U123ABC456",
+            "text": `<@${BOT_ID}> hello`,
+            "ts": "1355517523.000005"
+        }).event)
+        message.text = robot.adapter.replaceBotIdWithName(message)
+        await robot.receive(message)
+        assert.deepEqual(wasCalled, true)
+        robot.shutdown()
     })
 })

package/src/bot.js

@@ -20,7 +20,7 @@ class SlackClient {
       this.apiPageSize = parseInt(options.apiPageSize, 10);
     }
 
-    this.robot.logger.debug(`SocketModeClient initialized with options: ${JSON.stringify(options.socketModeOptions)}`);
+    this.robot.logger.debug(`SocketModeClient initialized with options: ${JSON.stringify(options.socketModeOptions) ?? ''}`);
 
     // Map to convert bot user IDs (BXXXXXXXX) to user representations for events from custom
     // integrations and apps without a bot user
@@ -58,23 +58,21 @@ class SlackClient {
     return this.socket.removeAllListeners();
   }
 
-  setTopic(conversationId, topic) {
+  async setTopic(conversationId, topic) {
     this.robot.logger.debug(`SlackClient#setTopic() with topic ${topic}`);
-    return this.web.conversations.info({channel: conversationId})
-      .then(res => {
-        const conversation = res.channel;
-        if (!conversation.is_im && !conversation.is_mpim) {
-          return this.web.conversations.setTopic({channel: conversationId, topic});
-        } else {
-          return this.robot.logger.debug(`Conversation ${conversationId} is a DM or MPDM. ` +
-                              "These conversation types do not have topics."
-          );
-        }
-    }).catch(error => {
-        return this.robot.logger.error(error, `Error setting topic in conversation ${conversationId}: ${error.message}`);
-    });
+    try {
+      const res = await this.web.conversations.info({channel: conversationId})
+      const conversation = res.channel;
+      if (!conversation.is_im && !conversation.is_mpim) {
+        return this.web.conversations.setTopic({channel: conversationId, topic});
+      } else {
+        return this.robot.logger.debug(`Conversation ${conversationId} is a DM or MPDM. These conversation types do not have topics.`);
+      }
+    } catch (error) {
+      this.robot.logger.error(error, `Error setting topic in conversation ${conversationId}: ${error.message}`);
+    }
   }
-  send(envelope, message) {
+  async send(envelope, message) {
     const room = envelope.room || envelope.id;
     if (room == null) {
       this.robot.logger.error("Cannot send message without a valid room. Envelopes should contain a room property set to a Slack conversation ID.");
@@ -83,13 +81,19 @@ class SlackClient {
     this.robot.logger.debug(`SlackClient#send() room: ${room}, message: ${message}`);
     if (typeof message !== "string") {
       message.channel = room
-      return this.web.chat.postMessage(message).then(result => {
+      try {
+        const result = await this.web.chat.postMessage(message)
         this.robot.logger.debug(`Successfully sent message to ${room}`)
-      }).catch(e => this.robot.logger.error(e, `SlackClient#send(message) error: ${e.message}`))
+      } catch (e) {
+        this.robot.logger.error(e, `SlackClient#send(message) error: ${e.message}`)
+      }
     } else {
-      return this.web.chat.postMessage({ channel: room, text: message }).then(result => {
+      try {
+        const result = await this.web.chat.postMessage({ channel: room, text: message })
         this.robot.logger.debug(`Successfully sent message (string) to ${room}`)
-      }).catch(e => this.robot.logger.error(e, `SlackClient#send(string) error: ${e.message}`))
+      } catch (e) {
+        this.robot.logger.error(e, `SlackClient#send(string) error: ${e.message}`)
+      }
     }
   }
   loadUsers(callback) {
@@ -121,20 +125,19 @@ class SlackClient {
     this.updateUserInBrain(r.user);
     return r.user;
   }
-  fetchConversation(conversationId) {
+  async fetchConversation(conversationId) {
     const expiration = Date.now() - SlackClient.CONVERSATION_CACHE_TTL_MS;
     if (((this.channelData[conversationId] != null ? this.channelData[conversationId].channel : undefined) != null) &&
       (expiration < (this.channelData[conversationId] != null ? this.channelData[conversationId].updated : undefined))) { return Promise.resolve(this.channelData[conversationId].channel); }
     if (this.channelData[conversationId] != null) { delete this.channelData[conversationId]; }
-    return this.web.conversations.info({channel: conversationId}).then(r => {
-      if (r.channel != null) {
-        this.channelData[conversationId] = {
-          channel: r.channel,
-          updated: Date.now()
-        };
-      }
-      return r.channel;
-    });
+    const r = await this.web.conversations.info({channel: conversationId})
+    if (r.channel != null) {
+      this.channelData[conversationId] = {
+        channel: r.channel,
+        updated: Date.now()
+      };
+    }
+    return r.channel;
   }
   updateUserInBrain(event_or_user) {
     let key, value;
@@ -246,7 +249,7 @@ class SlackBot extends Adapter {
    * @param {Object} envelope - fully documented in SlackClient
    * @param {...(string|Object)} messages - fully documented in SlackClient
    */
-  send(envelope, ...messages) {
+  async send(envelope, ...messages) {
     this.robot.logger.debug('Sending message to Slack');
     let callback = function() {};
     if (typeof(messages[messages.length - 1]) === "function") {
@@ -257,7 +260,15 @@ class SlackBot extends Adapter {
       // NOTE: perhaps do envelope manipulation here instead of in the client (separation of concerns)
       if (message !== "") { return this.client.send(envelope, message); }
     });
-    return Promise.all(messagePromises).then(callback.bind(null, null), callback);
+    let results = [];
+    try {
+      results = await Promise.all(messagePromises)
+      callback(null, null)
+    } catch (e) {
+      this.robot.logger.error(e);
+      callback(e, null);
+    }
+    return results;
   }
 
   /**
@@ -266,7 +277,7 @@ class SlackBot extends Adapter {
    * @param {Object} envelope - fully documented in SlackClient
    * @param {...(string|Object)} messages - fully documented in SlackClient
    */
-  reply(envelope, ...messages) {
+  async reply(envelope, ...messages) {
     this.robot.logger.debug('replying to message');
     let callback = function() {};
     if (typeof(messages[messages.length - 1]) === "function") {
@@ -283,7 +294,15 @@ class SlackBot extends Adapter {
         return this.client.send(envelope, message);
       }
     });
-    return Promise.all(messagePromises).then(callback.bind(null, null), callback);
+    let results = [];
+    try {
+      results = await Promise.all(messagePromises)
+      callback(null, null)
+    } catch (e) {
+      this.robot.logger.error(e);
+      callback(e, null);
+    }
+    return results;
   }
 
   /**
@@ -292,10 +311,8 @@ class SlackBot extends Adapter {
    * @param {Object} envelope - fully documented in SlackClient
    * @param {...string} strings - strings that will be newline separated and set to the conversation topic
    */
-  setTopic(envelope, ...strings) {
-    // TODO: if the sender is interested in the completion, the last item in `messages` will be a function
-    // TODO: this will fail if sending an object as a value in strings
-    return this.client.setTopic(envelope.room, strings.join("\n"));
+  async setTopic(envelope, ...strings) {
+    return await this.client.setTopic(envelope.room, strings.join("\n"));
   }
 
   /**
@@ -457,12 +474,13 @@ class SlackBot extends Adapter {
     // Hubot expects all user objects to have a room property that is used in the envelope for the message after it
     // is received
     from.room = channel ?? '';
-    from.name = from.profile.display_name;
+    from.name = from?.profile?.display_name ?? null;
 
     // add the bot id to the message if it's a direct message
     message.body.event.text = this.addBotIdToMessage(message.body.event);
     message.body.event.text = this.replaceBotIdWithName(message.body.event);
     this.robot.logger.debug(`Text = ${message.body.event.text}`);
+    this.robot.logger.debug(`Event subtype = ${message.body.event?.subtype}`);
     try {
       switch (message.event.type) {
         case "member_joined_channel":
@@ -470,13 +488,13 @@ class SlackBot extends Adapter {
           this.robot.logger.debug(`Received enter message for user: ${from.id}, joining: ${channel}`);
           msg = new EnterMessage(from);
           msg.ts = message.event.ts;
-          this.receive(msg);
+          await this.receive(msg);
           break;
         case "member_left_channel":
           this.robot.logger.debug(`Received leave message for user: ${from.id}, joining: ${channel}`);
           msg = new LeaveMessage(user);
           msg.ts = message.ts;
-          this.receive(msg);
+          await this.receive(msg);
           break;
         case "reaction_added": case "reaction_removed":
           // Once again Hubot expects all user objects to have a room property that is used in the envelope for the message
@@ -490,18 +508,20 @@ class SlackBot extends Adapter {
           const item_user = (message.body.event.item_user != null) ? this.robot.brain.userForId(message.body.event.item_user.id, message.body.event.item_user) : {};
   
           this.robot.logger.debug(`Received reaction message from: ${from.id}, reaction: ${message.body.event.reaction}, item type: ${message.body.event.item.type}`);
-          this.receive(new ReactionMessage(message.body.event.type, from, message.body.event.reaction, item_user, message.body.event.item, message.body.event.event_ts));
+          await this.receive(new ReactionMessage(message.body.event.type, from, message.body.event.reaction, item_user, message.body.event.item, message.body.event.event_ts));
           break;
         case "file_shared":  
           this.robot.logger.debug(`Received file_shared message from: ${message.body.event.user_id}, file_id: ${message.body.event.file_id}`);
-          this.receive(new FileSharedMessage(from, message.body.event.file_id, message.body.event.event_ts));
+          await this.receive(new FileSharedMessage(from, message.body.event.file_id, message.body.event.event_ts));
           break;
         default:
           this.robot.logger.debug(`Received generic message: ${message.event.type}`);
-          SlackTextMessage.makeSlackTextMessage(from, null, message?.body?.event.text, message?.body?.event, channel, this.robot.name, this.robot.alias, this.client, (error, message) => {
-            if (error) { return this.robot.logger.error(error, `Dropping message due to error ${error.message}`); }
-            return this.receive(message);
-          });
+          try {
+            const msg = await SlackTextMessage.makeSlackTextMessage(from, null, message?.body?.event.text, message?.body?.event, channel, this.robot.name, this.robot.alias, this.client)
+            await this.receive(msg);
+          } catch (error) {
+            this.robot.logger.error(error, `Dropping message due to error ${error.message}`);
+          }
           break;
       }
     } catch (e) {
@@ -528,5 +548,5 @@ class SlackBot extends Adapter {
     return res.members.map((member) => this.client.updateUserInBrain(member));
   }
 }
-
-module.exports = SlackBot;
+module.exports.SlackClient = SlackClient;
+module.exports.SlackBot = SlackBot;

package/src/message.js

@@ -1,5 +1,5 @@
-const {Message, TextMessage}  = require.main.require("hubot/es2015.js");
-const SlackClient = require("./client");
+const { Message, TextMessage, TopicMessage }  = require.main.require("hubot/es2015.js");
+const SlackClient = require("./bot.js");
 const SlackMention = require("./mention");
 
 class ReactionMessage extends Message {
@@ -114,10 +114,9 @@ class SlackTextMessage extends TextMessage {
    * @param {SlackClient} client - a client that can be used to get more data needed to build the text
    * @param {function} cb - callback for the result
    */
-  buildText(client, cb) {
+  async buildText(client) {
     // base text
     let text = (this.rawMessage.text != null) ? this.rawMessage.text : "";
-
     // flatten any attachments into text
     if (this.rawMessage.attachments) {
       const attachment_text = this.rawMessage.attachments.map(a => a.fallback).join("\n");
@@ -128,19 +127,18 @@ class SlackTextMessage extends TextMessage {
     const mentionFormatting = this.replaceLinks(client, text);
     // Fetch conversation info
     const fetchingConversationInfo = client.fetchConversation(this._channel_id);
-    return Promise.all([mentionFormatting, fetchingConversationInfo])
-      .then(results => {
-        const [ replacedText, conversationInfo ] = results;
-        text = replacedText;
-        text = text.replace(/&lt;/g, "<");
-        text = text.replace(/&gt;/g, ">");
-        text = text.replace(/&amp;/g, "&");
-        this.text = text;
-        return cb();
-    }).catch(error => {
-        client.robot.logger.error(error, `An error occurred while building text: ${error.message}`);
-        return cb(error);
-    });
+    let results = [];
+    try {
+      results = await Promise.all([mentionFormatting, fetchingConversationInfo]);
+      const [ replacedText, conversationInfo ] = results;
+      text = replacedText;
+      text = text.replace(/&lt;/g, "<");
+      text = text.replace(/&gt;/g, ">");
+      text = text.replace(/&amp;/g, "&");
+    } catch (e) {
+      client.robot.logger.error(e, `An error occurred while building text: ${e.message}`);
+    }
+    return text;
   }
 
   /**
@@ -271,22 +269,14 @@ class SlackTextMessage extends TextMessage {
    * @param {SlackClient} client - client used to fetch more data
    * @param {function} cb - callback to return the result
    */
-  static makeSlackTextMessage(user, text, rawText, rawMessage, channel_id, robot_name, robot_alias, client, cb) {
-    const message = new SlackTextMessage(user, text, rawText, rawMessage, channel_id, robot_name, robot_alias);
-
-    // creates a completion function that consistently calls the callback after this function has returned
-    const done = message => setImmediate(() => cb(null, message));
-
-    if ((message.text == null)) {
-      return message.buildText(client, function(error) {
-        if (error) {
-          return cb(error);
-        }
-        return done(message);
-      });
-    } else {
-      return done(message);
+  static async makeSlackTextMessage(user, text, rawText, rawMessage, channel_id, robot_name, robot_alias, client) {
+    if(rawMessage?.subtype) {
+      return new TopicMessage(user, rawMessage.text, rawMessage.event_ts)
     }
+    const message = new SlackTextMessage(user, text, rawText, rawMessage, channel_id, robot_name, robot_alias);
+    if (message.text !== null) return message;
+    message.text = await message.buildText(client);
+    return message;
   }
 }
 

package/test/bot.js

@@ -1,7 +1,7 @@
 const {describe, it, beforeEach, before, after} = require('node:test');
 const assert = require('node:assert/strict');
 const Module = require('module');
-const SlackBot = require('../src/bot.js');
+const SlackBot = require('../src/bot.js').SlackBot;
 
 const hookModuleToReturnMockFromRequire = (module, mock) => {
   const originalRequire = Module.prototype.require;
@@ -208,23 +208,6 @@ describe('Send Messages', function() {
   });
 });
 
-describe('Client sending message', function() {
-  let stubs, client;
-  beforeEach(function() {
-    ({stubs, client} = require('./stubs.js')());
-  });
-
-  it('Should append as_user = true', function() {
-    client.send({room: stubs.channel.id}, {text: 'foo', user: stubs.user, channel: stubs.channel.id});
-    assert.ok(stubs._opts.as_user);
-  });
-
-  it('Should append as_user = true only as a default', function() {
-    client.send({room: stubs.channel.id}, {text: 'foo', user: stubs.user, channel: stubs.channel.id, as_user: false});
-    assert.deepEqual(stubs._opts.as_user, true);
-  });
-});
-
 describe('Reply to Messages', function() {
   let stubs, slackbot;
   beforeEach(function() {
@@ -290,16 +273,18 @@ describe('Setting the channel topic', function() {
     ({stubs, slackbot} = require('./stubs.js')());
   });
 
-  it('Should set the topic in channels', function(t, done) {
+  it('Should set the topic in channels', async () => {
+    let wasCalled = false;
     stubs.receiveMock.onTopic = function(topic) {
       assert.deepEqual(topic, 'channel');
-      done();
+      wasCalled = true;
     };
-    slackbot.setTopic({room: stubs.channel.id}, 'channel');
+    await slackbot.setTopic({room: stubs.channel.id}, 'channel');
+    assert.deepEqual(wasCalled, true);
   });
 
-  it('Should NOT set the topic in DMs', function() {
-    slackbot.setTopic({room: 'D1232'}, 'DM');
+  it('Should NOT set the topic in DMs', async () => {
+    await slackbot.setTopic({room: 'D1232'}, 'DM');
     assert.equal(stubs._topic, undefined);
   });
 });