@pipedream/slack 0.3.2 → 0.4.1

package/sources/new-direct-message/new-direct-message.mjs

@@ -0,0 +1,51 @@
+import common from "../common/base.mjs";
+
+export default {
+  ...common,
+  key: "slack-new-direct-message",
+  name: "New Direct Message (Instant)",
+  version: "1.0.1",
+  description: "Emit new event when a message was posted in a direct message channel",
+  type: "source",
+  dedupe: "unique",
+  props: {
+    ...common.props,
+    // eslint-disable-next-line pipedream/props-description,pipedream/props-label
+    slackApphook: {
+      type: "$.interface.apphook",
+      appProp: "slack",
+      async eventNames() {
+        return [
+          "message.im",
+        ];
+      },
+    },
+    ignoreMyself: {
+      propDefinition: [
+        common.props.slack,
+        "ignoreMyself",
+      ],
+    },
+    ignoreBot: {
+      propDefinition: [
+        common.props.slack,
+        "ignoreBot",
+      ],
+    },
+  },
+  methods: {
+    ...common.methods,
+    getSummary() {
+      return "New direct message received";
+    },
+    processEvent(event) {
+      if (this.ignoreMyself && event.user == this.slack.mySlackId()) {
+        return;
+      }
+      if ((this.ignoreBot) && (event.subtype == "bot_message" || event.bot_id)) {
+        return;
+      }
+      return event;
+    },
+  },
+};

package/sources/new-mention/new-mention.mjs

@@ -0,0 +1,95 @@
+import common from "../common/base.mjs";
+
+export default {
+  ...common,
+  key: "slack-new-mention",
+  name: "New Mention (Instant)",
+  version: "1.0.1",
+  description: "Emit new event when a username or specific keyword is mentioned in a channel",
+  type: "source",
+  dedupe: "unique",
+  props: {
+    ...common.props,
+    conversations: {
+      propDefinition: [
+        common.props.slack,
+        "conversation",
+      ],
+      type: "string[]",
+      label: "Channels",
+      description: "Select one or more channels to monitor for new messages.",
+      optional: true,
+    },
+    // eslint-disable-next-line pipedream/props-description,pipedream/props-label
+    slackApphook: {
+      type: "$.interface.apphook",
+      appProp: "slack",
+      async eventNames() {
+        return this.conversations || [
+          "message",
+        ];
+      },
+    },
+    keyword: {
+      propDefinition: [
+        common.props.slack,
+        "keyword",
+      ],
+    },
+    isUsername: {
+      propDefinition: [
+        common.props.slack,
+        "isUsername",
+      ],
+    },
+    ignoreBot: {
+      propDefinition: [
+        common.props.slack,
+        "ignoreBot",
+      ],
+    },
+  },
+  methods: {
+    ...common.methods,
+    getSummary() {
+      return "New mention received";
+    },
+    async processEvent(event) {
+      if (event.type !== "message") {
+        console.log(`Ignoring event with unexpected type "${event.type}"`);
+        return;
+      }
+      if (event.subtype != null && event.subtype != "bot_message" && event.subtype != "file_share") {
+      // This source is designed to just emit an event for each new message received.
+      // Due to inconsistencies with the shape of message_changed and message_deleted
+      // events, we are ignoring them for now. If you want to handle these types of
+      // events, feel free to change this code!!
+        console.log("Ignoring message with subtype.");
+        return;
+      }
+      if ((this.ignoreBot) && (event.subtype == "bot_message" || event.bot_id)) {
+        return;
+      }
+      let emitEvent = false;
+      const elements = event.blocks[0]?.elements[0]?.elements;
+
+      if (this.isUsername && elements) {
+        for (const item of elements) {
+          if (item.user_id) {
+            const username = await this.getUserName(item.user_id);
+            if (username === this.word) {
+              emitEvent = true;
+              break;
+            }
+          }
+        }
+
+      } else if (event.text.indexOf(this.word) !== -1) {
+        emitEvent = true;
+      }
+      if (emitEvent) {
+        return event;
+      }
+    },
+  },
+};

package/sources/new-message-in-channels/new-message-in-channels.mjs

@@ -0,0 +1,84 @@
+import common from "../common/base.mjs";
+
+export default {
+  ...common,
+  key: "slack-new-message-in-channels",
+  name: "New Message In Channels (Instant)",
+  version: "1.0.1",
+  description: "Emit new event when a new message is posted to one or more channels",
+  type: "source",
+  dedupe: "unique",
+  props: {
+    ...common.props,
+    conversations: {
+      propDefinition: [
+        common.props.slack,
+        "conversation",
+      ],
+      type: "string[]",
+      label: "Channels",
+      description: "Select one or more channels to monitor for new messages.",
+      optional: true,
+    },
+    // eslint-disable-next-line pipedream/props-description,pipedream/props-label
+    slackApphook: {
+      type: "$.interface.apphook",
+      appProp: "slack",
+      async eventNames() {
+        return this.conversations || [
+          "message",
+        ];
+      },
+    },
+    resolveNames: {
+      propDefinition: [
+        common.props.slack,
+        "resolveNames",
+      ],
+    },
+    ignoreBot: {
+      propDefinition: [
+        common.props.slack,
+        "ignoreBot",
+      ],
+    },
+  },
+  methods: {
+    ...common.methods,
+    getSummary() {
+      return "New message in channel";
+    },
+    async processEvent(event) {
+      if (event.type !== "message") {
+        console.log(`Ignoring event with unexpected type "${event.type}"`);
+        return;
+      }
+      if (event.subtype != null && event.subtype != "bot_message" && event.subtype != "file_share") {
+        // This source is designed to just emit an event for each new message received.
+        // Due to inconsistencies with the shape of message_changed and message_deleted
+        // events, we are ignoring them for now. If you want to handle these types of
+        // events, feel free to change this code!!
+        console.log("Ignoring message with subtype.");
+        return;
+      }
+      if ((this.ignoreBot) && (event.subtype == "bot_message" || event.bot_id)) {
+        return;
+      }
+      if (this.resolveNames) {
+        if (event.user) {
+          event.user_id = event.user;
+          event.user = await this.getUserName(event.user);
+        } else if (event.bot_id) {
+          event.bot = await this.getBotName(event.bot_id);
+        }
+        event.channel_id = event.channel;
+        event.channel = await this.getConversationName(event.channel);
+        if (event.team) {
+          event.team_id = event.team;
+          event.team = await this.getTeamName(event.team);
+        }
+      }
+      return event;
+    },
+  },
+};

package/sources/new-reaction-added/new-reaction-added.mjs

@@ -0,0 +1,65 @@
+import common from "../common/base.mjs";
+
+export default {
+  ...common,
+  key: "slack-new-reaction-added",
+  name: "New Reaction Added (Instant)",
+  version: "1.1.1",
+  description: "Emit new event when a member has added an emoji reaction to an item",
+  type: "source",
+  dedupe: "unique",
+  props: {
+    ...common.props,
+    conversations: {
+      propDefinition: [
+        common.props.slack,
+        "conversation",
+      ],
+      type: "string[]",
+      label: "Channels",
+      description: "Select one or more channels to monitor for new messages.",
+      optional: true,
+    },
+    // eslint-disable-next-line pipedream/props-description,pipedream/props-label
+    slackApphook: {
+      type: "$.interface.apphook",
+      appProp: "slack",
+      async eventNames() {
+        if (this.conversations.length) {
+          const conversations = [];
+          for (const conversation of this.conversations) {
+            conversations.push(`reaction_added:${conversation}`);
+          }
+          return conversations;
+        }
+
+        return [
+          "reaction_added",
+        ];
+      },
+    },
+    ignoreBot: {
+      propDefinition: [
+        common.props.slack,
+        "ignoreBot",
+      ],
+    },
+  },
+  methods: {
+    ...common.methods,
+    getSummary() {
+      return "New reaction added";
+    },
+    async processEvent(event) {
+      if ((this.ignoreBot) && (event.subtype == "bot_message" || event.bot_id)) {
+        return;
+      }
+      event.message = await this.getLastMessage({
+        channel: event.item.channel,
+        event_ts: event.item.ts,
+      });
+
+      return event;
+    },
+  },
+};

package/sources/new-star-added/new-star-added.mjs

@@ -0,0 +1,46 @@
+import common from "../common/base.mjs";
+import {
+  events,
+  eventsOptions,
+} from "../common/constants.mjs";
+
+export default {
+  ...common,
+  key: "slack-new-star-added",
+  name: "New Star Added (Instant)",
+  version: "0.0.4",
+  description: "Emit new event when a star is added to an item",
+  type: "source",
+  dedupe: "unique",
+  props: {
+    ...common.props,
+    // eslint-disable-next-line pipedream/props-description,pipedream/props-label
+    slackApphook: {
+      type: "$.interface.apphook",
+      appProp: "slack",
+      async eventNames() {
+        return [
+          "star_added",
+        ];
+      },
+    },
+    eventTypes: {
+      type: "string[]",
+      label: "Event Types",
+      description: "The types of event to emit. If not specified, all events will be emitted.",
+      options: eventsOptions,
+      optional: true,
+    },
+  },
+  methods: {
+    ...common.methods,
+    getSummary({ item: { type } }) {
+      return `New star added - ${events[type] ?? type}`;
+    },
+    async processEvent(event) {
+      if (this.eventTypes?.length === 0 || this.eventTypes.includes(event.item.type)) {
+        return event;
+      }
+    },
+  },
+};

package/slack.app.js

@@ -1,48 +0,0 @@
-const { WebClient } = require('@slack/web-api')
-
-module.exports = {
-  type: "app",
-  app: "slack",
-  methods: {
-    mySlackId() {
-      return this.$auth.oauth_uid
-    },
-    sdk() {
-      return new WebClient(this.$auth.oauth_access_token)
-    },
-    async scopes() {
-      const resp = await this.sdk().auth.test()
-      if (resp.ok) {
-        return resp.response_metadata.scopes
-      } else {
-        console.log("Error getting scopes", resp.error)
-        throw(resp.error)
-      }
-    },
-    async availableConversations(types, cursor) {
-      const params = {
-        types,
-        cursor,
-        limit: 10,
-        exclude_archived: true,
-        user: this.$auth.oauth_uid,
-      }
-      const resp = await this.sdk().users.conversations(params)
-      if (resp.ok) {
-        return { cursor: resp.response_metadata.next_cursor, conversations: resp.channels }
-      } else {
-        console.log("Error getting conversations", resp.error)
-        throw(resp.error)
-      }
-    },
-    async users(cursor) {
-      const resp = await this.sdk().users.list({ cursor })
-      if (resp.ok) {
-        return { users: resp.members, cursor: resp.response_metadata.next_cursor }
-      } else {
-        console.log("Error getting users", resp.error)
-        throw(resp.error)
-      }
-    },
-  },
-}

package/sources/new-message-in-channels/new-message-in-channels.js

@@ -1,151 +0,0 @@
-const slack = require('../../slack.app.js')
-
-module.exports = {
-  key: "slack-new-message-in-channels",
-  name: "New Message In Channels",
-  version: "0.0.1",
-  description: "Emit an event when a new message is posted to a one or more channels",
-  dedupe: "unique",
-  props: {
-    slack,
-    conversations: {
-      type: "string[]",
-      label: "Channels",
-      description: "Select one or more channels to monitor for new messages.",
-      optional: true,
-      async options({ prevContext }) {
-        let { types, cursor, userNames } = prevContext
-        if (types == null) {
-          const scopes = await this.slack.scopes()
-          types = ["public_channel"]
-          if (scopes.includes("groups:read")) {
-            types.push("private_channel")
-          }
-          if (scopes.includes("mpim:read")) {
-            types.push("mpim")
-          }
-          if (scopes.includes("im:read")) {
-            types.push("im")
-            // TODO use paging
-            userNames = {}
-            for (const user of (await this.slack.users()).users) {
-              userNames[user.id] = user.name
-            }
-          }
-        }
-        const resp = await this.slack.availableConversations(types.join(), cursor)
-        return {
-          options: resp.conversations.map((c) => {
-            if (c.is_im) {
-              return { label: `Direct messaging with: @${userNames[c.user]}`, value: c.id }
-            } else if (c.is_mpim) {
-              return { label: c.purpose.value, value: c.id }
-            } else {
-              return { label: `${c.is_private ? "Private" : "Public"} channel: ${c.name}`, value: c.id }
-            }
-          }),
-          context: { types, cursor: resp.cursor, userNames },
-        }
-      },
-    },
-    slackApphook: {
-      type: "$.interface.apphook",
-      appProp: "slack",
-      async eventNames() {
-        return this.conversations || []
-      },
-    },
-    ignoreMyself: {
-      type: "boolean",
-      label: "Ignore myself",
-      description: "Ignore messages from me",
-      default: true,
-    },
-    resolveNames: {
-      type: "boolean",
-      label: "Resolve names",
-      description: "Resolve user and channel names (incurs extra API calls)",
-      default: false,
-    },
-    nameCache: "$.service.db",
-  },
-  methods: {
-    async maybeCached(key, refreshVal, timeoutMs = 3600000) {
-      let record = this.nameCache.get(key)
-      const time = Date.now()
-      if (!record || time - record.ts > timeoutMs) {
-        record = { ts: time, val: await refreshVal() }
-        this.nameCache.set(key, record)
-      }
-      return record.val
-    },
-    async getBotName(id) {
-      return this.maybeCached(`bots:${id}`, async () => {
-        const info = await this.slack.sdk().bots.info({ bot: id })
-        if (!info.ok) throw new Error(info.error)
-        return info.bot.name
-      })
-    },
-    async getUserName(id) {
-      return this.maybeCached(`users:${id}`, async () => {
-        const info = await this.slack.sdk().users.info({ user: id })
-        if (!info.ok) throw new Error(info.error)
-        return info.user.name
-      })
-    },
-    async getConversationName(id) {
-      return this.maybeCached(`conversations:${id}`, async () => {
-        const info = await this.slack.sdk().conversations.info({ channel: id })
-        if (!info.ok) throw new Error(info.error)
-        if (info.channel.is_im) {
-          return `DM with ${await this.getUserName(info.channel.user)}`
-        } else {
-          return info.channel.name
-        }
-      })
-    },
-    async getTeamName(id) {
-      return this.maybeCached(`team:${id}`, async (info) => {
-        try {
-          const info = await this.slack.sdk().team.info({ team: id })
-          return info.team.name
-        } catch (err) {
-          console.log("Error getting team name, probably need to re-connect the account at pipedream.com/apps", err)
-          return id
-        }
-      })
-    },
-  },
-  async run(event) {
-    if (event.subtype != null && event.subtype != "bot_message") {
-      // This source is designed to just emit an event for each new message received.
-      // Due to inconsistencies with the shape of message_changed and message_deleted
-      // events, we are ignoring them for now. If you want to handle these types of
-      // events, feel free to change this code!!
-      console.log("Ignoring message with subtype.")
-      return
-    }
-    if (this.ignoreMyself && event.user == this.slack.mySlackId()) {
-      return
-    }
-    if (this.resolveNames) {
-      if (event.user) {
-        event.user_id = event.user
-        event.user = await this.getUserName(event.user)
-      } else if (event.bot_id) {
-        event.bot = await this.getBotName(event.bot_id)
-      }
-      event.channel_id = event.channel
-      event.channel = await this.getConversationName(event.channel)
-      if (event.team) {
-        event.team_id = event.team
-        event.team = await this.getTeamName(event.team)
-      }
-    }
-    if (!event.client_msg_id) {
-      event.pipedream_msg_id = `pd_${Date.now()}_${Math.random().toString(36).substr(2, 10)}`
-    }
-
-    this.$emit(event, { id: event.client_msg_id || event.pipedream_msg_id })
-  },
-}