@pipedream/slack_v2 0.0.1

package/sources/common/base.mjs

@@ -0,0 +1,184 @@
+import slack from "../../slack_v2.app.mjs";
+import {
+  NAME_CACHE_MAX_SIZE, NAME_CACHE_TIMEOUT,
+} from "./constants.mjs";
+
+export default {
+  props: {
+    slack,
+    db: "$.service.db",
+  },
+  methods: {
+    _getNameCache() {
+      return this.db.get("nameCache") ?? {};
+    },
+    _setNameCache(cacheObj) {
+      this.db.set("nameCache", cacheObj);
+    },
+    _getLastCacheCleanup() {
+      return this.db.get("lastCacheCleanup") ?? 0;
+    },
+    _setLastCacheCleanup(time) {
+      this.db.set("lastCacheCleanup", time);
+    },
+    cleanCache(cacheObj) {
+      console.log("Initiating cache check-up...");
+      const timeout = Date.now() - NAME_CACHE_TIMEOUT;
+
+      const entries = Object.entries(cacheObj);
+      let cleanArr = entries.filter(
+        ([
+          , { ts },
+        ]) => ts > timeout,
+      );
+      const diff = entries.length - cleanArr.length;
+      if (diff) {
+        console.log(`Cleaned up ${diff} outdated cache entries.`);
+      }
+
+      if (cleanArr.length > NAME_CACHE_MAX_SIZE) {
+        console.log(`Reduced the cache from ${cleanArr.length} to ${NAME_CACHE_MAX_SIZE / 2} entries.`);
+        cleanArr = cleanArr.slice(NAME_CACHE_MAX_SIZE / -2);
+      }
+
+      const cleanObj = Object.fromEntries(cleanArr);
+      return cleanObj;
+    },
+    getCache() {
+      let cacheObj = this._getNameCache();
+
+      const lastCacheCleanup = this._getLastCacheCleanup();
+      const time = Date.now();
+
+      const shouldCleanCache = time - lastCacheCleanup > NAME_CACHE_TIMEOUT / 2;
+      if (shouldCleanCache) {
+        cacheObj = this.cleanCache(cacheObj);
+        this._setLastCacheCleanup(time);
+      }
+
+      return [
+        cacheObj,
+        shouldCleanCache,
+      ];
+    },
+    async maybeCached(key, refreshVal) {
+      let [
+        cacheObj,
+        wasUpdated,
+      ] = this.getCache();
+      let record = cacheObj[key];
+      const time = Date.now();
+      if (!record || time - record.ts > NAME_CACHE_TIMEOUT) {
+        record = {
+          ts: time,
+          val: await refreshVal(),
+        };
+        cacheObj[key] = record;
+        wasUpdated = true;
+      }
+
+      if (wasUpdated) {
+        this._setNameCache(cacheObj);
+      }
+
+      return record.val;
+    },
+    async getUserName(id) {
+      return this.maybeCached(`users:${id}`, async () => {
+        const info = await this.slack.usersInfo({
+          user: id,
+        });
+        if (!info.ok) throw new Error(info.error);
+        return info.user.name;
+      });
+    },
+    async getRealName(id) {
+      return this.maybeCached(`users_real_names:${id}`, async () => {
+        const info = await this.slack.usersInfo({
+          user: id,
+        });
+        if (!info.ok) throw new Error(info.error);
+        return info.user.real_name;
+      });
+    },
+    async getBotName(id) {
+      return this.maybeCached(`bots:${id}`, async () => {
+        const info = await this.slack.getBotInfo({
+          bot: id,
+        });
+        if (!info.ok) throw new Error(info.error);
+        return info.bot.name;
+      });
+    },
+    async getConversationName(id) {
+      return this.maybeCached(`conversations:${id}`, async () => {
+        const info = await this.slack.conversationsInfo({
+          channel: id,
+        });
+        if (!info.ok) throw new Error(info.error);
+        if (info.channel.is_im) {
+          return `DM with ${await this.getUserName(info.channel.user)}`;
+        }
+        return info.channel.name;
+      });
+    },
+    async getTeamName(id) {
+      return this.maybeCached(`team:${id}`, async () => {
+        try {
+          const info = await this.slack.getTeamInfo({
+            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 getMessage({
+      channel, event_ts: ts,
+    }) {
+      return await this.maybeCached(
+        `lastMessage:${channel}:${ts}`,
+        async () => {
+          const response = await this.slack.getConversationReplies({
+            channel,
+            ts,
+            limit: 1,
+          });
+
+          if (response.messages.length) {
+            response.messages = [
+              response.messages[0],
+            ];
+          }
+
+          return response;
+        },
+      );
+    },
+    processEvent(event) {
+      return event;
+    },
+  },
+  async run(event) {
+    event = await this.processEvent(event);
+
+    if (event) {
+      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 || event.channel.id,
+        summary: this.getSummary(event),
+        ts: event.event_ts || Date.now(),
+      });
+    }
+  },
+};

package/sources/common/constants.mjs

@@ -0,0 +1,58 @@
+const events = {
+  im: "User",
+  message: "Message",
+  file: "File",
+  channel: "Channel",
+};
+
+const eventsOptions = [
+  {
+    label: "User",
+    value: "im",
+  },
+  {
+    label: "Message",
+    value: "message",
+  },
+  {
+    label: "File",
+    value: "file",
+  },
+  {
+    label: "Channel",
+    value: "channel",
+  },
+];
+
+const SUBTYPE = {
+  NULL: null,
+  BOT_MESSAGE: "bot_message",
+  FILE_SHARE: "file_share",
+  PD_HISTORY_MESSAGE: "pd_history_message",
+  MESSAGE_REPLIED: "message_replied",
+};
+
+const ALLOWED_SUBTYPES = [
+  SUBTYPE.NULL,
+  SUBTYPE.BOT_MESSAGE,
+  SUBTYPE.FILE_SHARE,
+  SUBTYPE.PD_HISTORY_MESSAGE,
+];
+
+const ALLOWED_MESSAGE_IN_CHANNEL_SUBTYPES = [
+  SUBTYPE.NULL,
+  SUBTYPE.BOT_MESSAGE,
+  SUBTYPE.FILE_SHARE,
+  SUBTYPE.MESSAGE_REPLIED,
+];
+
+export const NAME_CACHE_MAX_SIZE = 1000;
+export const NAME_CACHE_TIMEOUT = 3600000;
+
+export default {
+  events,
+  eventsOptions,
+  SUBTYPE,
+  ALLOWED_SUBTYPES,
+  ALLOWED_MESSAGE_IN_CHANNEL_SUBTYPES,
+};

package/sources/new-channel-created/new-channel-created.mjs

@@ -0,0 +1,32 @@
+import common from "../common/base.mjs";
+import sampleEmit from "./test-event.mjs";
+
+export default {
+  ...common,
+  key: "slack_v2-new-channel-created",
+  name: "New Channel Created (Instant)",
+  version: "0.0.11",
+  description: "Emit new event when a new channel is created.",
+  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 [
+          "channel_created",
+        ];
+      },
+    },
+  },
+  methods: {
+    ...common.methods,
+    getSummary({ channel: { name } }) {
+      return `New channel created - ${name}`;
+    },
+  },
+  sampleEmit,
+};

package/sources/new-channel-created/test-event.mjs

@@ -0,0 +1,44 @@
+export default  {
+	"type": "channel_created",
+	"channel": {
+		"id": "C024BE91L",
+		"name": "fun",
+    "is_channel": true,
+    "is_group": false,
+    "is_im": false,
+    "is_mpim": false,
+    "is_private": false,
+		"created": 1360782804,
+    "is_archived": false,
+    "is_general": false,
+    "unlinked": 0,
+    "name_normalized": "fun",
+    "is_shared": false,
+    "is_frozen": false,
+    "is_org_shared": false,
+    "is_pending_ext_shared": false,
+    "pending_shared": [],
+    "context_team_id": "TLZ203R5",
+    "updated": 1714140253251,
+    "parent_conversation": null,
+		"creator": "U024BE7LH",
+    "is_ext_shared": false,
+    "shared_team_ids": [
+      "TLZ203R5"
+    ],
+    "pending_connected_team_ids": [],
+    "topic": {
+      "value": "",
+      "creator": "",
+      "last_set": 0
+    },
+    "purpose": {
+      "value": "",
+      "creator": "",
+      "last_set": 0
+    },
+    "previous_names": []
+	},
+  "event_ts": "1714140253.002700",
+  "pipedream_msg_id": "pd_1714140255038_bkbl3pxpkp"
+}

package/sources/new-interaction-event-received/README.md

@@ -0,0 +1,85 @@
+# Overview
+
+Slack messages can contain interactive elements like buttons, dropdowns, radio buttons, and more. This source subscribes to interactive events, like when a button is clicked in a message.
+
+![Example of a Slack button](https://res.cloudinary.com/pipedreamin/image/upload/v1668443788/docs/components/CleanShot_2022-11-10_at_10.17.172x_dxdz1o.png)
+
+Then this source will be triggered when you or another Slack user in your workspace clicks a button, selects an option or fills out a form.
+
+![Example feed of interaction events coming from Slack](https://res.cloudinary.com/pipedreamin/image/upload/v1668443818/docs/components/CleanShot_2022-11-10_at_10.19.152x_eyiims.png)
+
+With this trigger, you can build workflows that perform some work with other APIs or services, and then reply back to the original message.
+
+# Getting Started
+
+<iframe width="560" height="315" src="https://www.youtube.com/embed/RZ3XQENkjeg" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>
+
+Watch this short video to learn how to use this in a workflow, or follow the guide below.
+
+First, if you haven’t already - send yourself a message containing one or more interactive elements. Use the ******************Sending the message with an interactive element****************** guide below to send a message containing a button.
+
+If you have already sent a message containing an element, skip to **********************************************Configuring the source.**********************************************
+
+## Sending the message with an interactive element
+
+The easiest way is to send yourself a message using the ****************************Slack - Send Message Using Block Kit**************************** action:
+
+![Selecting the Send Slack Message with Block Kit](https://res.cloudinary.com/pipedreamin/image/upload/v1668443844/docs/components/CleanShot_2022-11-10_at_10.25.522x_vxiooo.png)
+
+Then select a **************Channel************** you’d like to send the message to, and use the **************[Block Kit Builder](https://app.slack.com/block-kit-builder/)************** to build a message, or just copy the example button blocks below:
+
+```jsx
+[
+  {
+    "type": "actions",
+    "elements": [
+      {
+        "type": "button",
+        "text": {
+          "type": "plain_text",
+          "text": "Click Me",
+          "emoji": true
+        },
+        "value": "click_me_123",
+        "action_id": "button_click"
+      }
+    ]
+  }
+]
+```
+
+Your ******************Slack - Send Message Using Block Kit****************** should look like this:
+
+![Setting up the block kit message with a button block](https://res.cloudinary.com/pipedreamin/image/upload/v1668443887/docs/components/CleanShot_2022-11-10_at_10.29.552x_kvfznm.png)
+
+## Configuring the source
+
+By default, this source will listen to ******all****** interactive events from your Slack workspace that your connected Slack account has authorization to view. Please note that only messages created via [Slack - Send Block Kit Message](https://pipedream.com/apps/slack-v2/actions/send-block-kit-message) Action, or via API call from the Pipedream app will emit an interaction event with this trigger. Block kit messages sent directly via the Slack's block kit builder will not trigger an interaction event.
+
+You can filter these events by selecting a specific **************channel************** and/or a specific **********action_id.**********
+
+### Filtering interactive events by channel
+
+Use the ****************Channels**************** dropdown to search for a specific channel for this source to subscribe to. ********Only******** button clicks, dropdown selects, etc. *in this selected channel* will trigger the source.
+
+### Filtering interactive events by `action_id`
+
+For more specificity, you can filter based on the passed `action_id` to the message.
+
+The `action_id` is arbitrary. It’s defined on the initial message sending the button, dropdown, or other interactive element’s markup.
+
+For example, in the section above using the Block Kit to create a message, we defined the button’s `action_id` as `"button_click"`. But you can choose whichever naming convention you’d like.
+
+If you pass `button_click` as a required `action_id` to this source, then only interactivity events with the `action_id` of `"button_click"` will trigger this source.
+
+## Troubleshooting
+
+### I’m clicking buttons, but no events are being received
+
+Follow these steps to make sure your source is configured correctly:
+
+1. Make sure that your `action_id` or ****************channels**************** filters apply to that message, remove the filters to make sure that’s not the case.
+
+1. Make sure that the message comes from the same Slack account that this source is configured with.
+
+1. Make sure that the message was sent via Pipedream action (e.g. [Slack - Send Block Kit Message](https://pipedream.com/apps/slack-v2/actions/send-block-kit-message) Action) or via API call from the Pipedream app.

package/sources/new-interaction-event-received/new-interaction-event-received.mjs

@@ -0,0 +1,105 @@
+import common from "../common/base.mjs";
+import sampleEmit from "./test-event.mjs";
+
+export default {
+  name: "New Interaction Events (Instant)",
+  version: "0.0.21",
+  key: "slack_v2-new-interaction-event-received",
+  description: "Emit new events on new Slack [interactivity events](https://api.slack.com/interactivity) sourced from [Block Kit interactive elements](https://api.slack.com/interactivity/components), [Slash commands](https://api.slack.com/interactivity/slash-commands), or [Shortcuts](https://api.slack.com/interactivity/shortcuts).",
+  type: "source",
+  props: {
+    ...common.props,
+    alert: {
+      type: "alert",
+      alertType: "info",
+      content: "Please note that only messages created via Pipedream's [Send Block Kit Message](https://pipedream.com/apps/slack/actions/send-block-kit-message) Action, or via API call from the Pipedream app will emit an interaction event with this trigger. \n\nBlock kit messages sent directly via the Slack's block kit builder will not trigger an interaction event. \n\nSee the [documentation](https://pipedream.com/apps/slack/triggers/new-interaction-event-received) for more details.",
+    },
+    action_ids: {
+      type: "string[]",
+      label: "Action IDs",
+      description: "Filter interaction events by specific `action_id`'s to subscribe for new interaction events. If none are specified, all `action_ids` created via Pipedream will emit new events.",
+      optional: true,
+      default: [],
+    },
+    conversations: {
+      propDefinition: [
+        common.props.slack,
+        "conversation",
+      ],
+      type: "string[]",
+      label: "Channels",
+      description: "Filter interaction events by one or more channels. If none selected, any interaction event in any channel will emit new events.",
+      optional: true,
+      default: [],
+    },
+    // eslint-disable-next-line pipedream/props-description,pipedream/props-label
+    slackApphook: {
+      type: "$.interface.apphook",
+      appProp: "slack",
+      /**
+       * Subscribes to potentially 4 different events:
+       * `interaction_events` - all interaction events on the authenticated account
+       * `interaction_events:${action_id}` - all interaction events with a specific given action_id
+       * `interaction_events:${channel_id}` - all interaction events within a specific channel
+       * `interaction_events:${channel_id}:${action_id}` - action_id within a specific channel
+       * @returns string[]
+       */
+      async eventNames() {
+        // start with action_ids, since they can be the most specific
+        const action_events = this.action_ids.reduce((carry, action_id) => {
+          // if channels are provided, spread them
+          if (this.conversations && this.conversations.length > 0) {
+            return [
+              ...carry,
+              ...this.conversations.map(
+                (channel) => `interaction_events:${channel}:${action_id}`,
+              ),
+            ];
+          }
+
+          return [
+            ...carry,
+            `interaction_events:${action_id}`,
+          ];
+        }, []);
+
+        if (action_events.length > 0) return action_events;
+
+        // if no action_ids are specified, move down to channels
+        const channel_events = this.conversations.map(
+          (channel) => `interaction_events:${channel}`,
+        );
+
+        if (channel_events.length > 0) return channel_events;
+
+        // if not specific action_ids or channels are specified, subscribe to all events
+        return [
+          "interaction_events",
+        ];
+      },
+    },
+  },
+  methods: {},
+  async run(event) {
+    this.$emit(
+      {
+        event,
+      },
+      {
+        summary: `New interaction event${
+          event?.channel?.id
+            ? ` in channel ${event.channel.id}`
+            : ""
+        }${
+          event.actions?.length > 0
+            ? ` from action_ids ${event.actions
+              .map((action) => action.action_id)
+              .join(", ")}`
+            : ""
+        }`,
+        ts: Date.now(),
+      },
+    );
+  },
+  sampleEmit,
+};

package/sources/new-interaction-event-received/test-event.mjs

@@ -0,0 +1,86 @@
+export default {
+  "event": {
+    "type": "block_actions",
+    "user": {
+      "id": "US676PZLY",
+      "username": "test.user",
+      "name": "test.user",
+      "team_id": "TS8319547"
+    },
+    "api_app_id": "AN9231S6L",
+    "token": "UYc82mtyZWRhvUXQ6TXrv4wq",
+    "container": {
+      "type": "message",
+      "message_ts": "1716402983.247149",
+      "channel_id": "CS8319KD5",
+      "is_ephemeral": false
+    },
+    "trigger_id": "7161731794692.892103311143.4020ed3595908eca11e4076438354dbb",
+    "team": {
+      "id": "TS8319547",
+      "domain": "test-j1q3506"
+    },
+    "enterprise": null,
+    "is_enterprise_install": false,
+    "channel": {
+      "id": "CS8319KD5",
+      "name": "testing"
+    },
+    "message": {
+      "subtype": "bot_message",
+      "text": "Click Me button Sent via <https://pipedream.com/@/p_6lCR5Nx?o=a&amp;a=slack|Pipedream>",
+      "username": "Pipedream",
+      "type": "message",
+      "ts": "1716402983.247149",
+      "bot_id": "BRTDL45RQ",
+      "app_id": "AN9231S6L",
+      "blocks": [
+        {
+          "type": "actions",
+          "block_id": "SJp0j",
+          "elements": [
+            {
+              "type": "button",
+              "action_id": "button_click",
+              "text": {
+                "type": "plain_text",
+                "text": "Click Me",
+                "emoji": true
+              },
+              "value": "click_me_123"
+            }
+          ]
+        },
+        {
+          "type": "context",
+          "block_id": "ysmBN",
+          "elements": [
+            {
+              "type": "mrkdwn",
+              "text": "Sent via <https://pipedream.com/@/p_6lCR5Nx?o=a&amp;a=slack|Pipedream>",
+              "verbatim": false
+            }
+          ]
+        }
+      ]
+    },
+    "state": {
+      "values": {}
+    },
+    "response_url": "https://hooks.slack.com/actions/TS8319547/7156351250101/J0w1NoVIXjChEwp4WQab4tcv",
+    "actions": [
+      {
+        "action_id": "button_click",
+        "block_id": "SJp0j",
+        "text": {
+          "type": "plain_text",
+          "text": "Click Me",
+          "emoji": true
+        },
+        "value": "click_me_123",
+        "type": "button",
+        "action_ts": "1716403200.549150"
+      }
+    ]
+  }
+}

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

@@ -0,0 +1,99 @@
+import common from "../common/base.mjs";
+import constants from "../common/constants.mjs";
+import sampleEmit from "./test-event.mjs";
+import sharedConstants from "../../common/constants.mjs";
+
+export default {
+  ...common,
+  key: "slack_v2-new-keyword-mention",
+  name: "New Keyword Mention (Instant)",
+  version: "0.1.0",
+  description: "Emit new event when a specific keyword is mentioned in a channel",
+  type: "source",
+  dedupe: "unique",
+  props: {
+    ...common.props,
+    conversations: {
+      propDefinition: [
+        common.props.slack,
+        "conversation",
+        () => ({
+          types: [
+            sharedConstants.CHANNEL_TYPE.PUBLIC,
+            sharedConstants.CHANNEL_TYPE.PRIVATE,
+          ],
+        }),
+      ],
+      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",
+      ],
+    },
+    ignoreBot: {
+      propDefinition: [
+        common.props.slack,
+        "ignoreBot",
+      ],
+    },
+  },
+  methods: {
+    ...common.methods,
+    getSummary() {
+      return "New keyword mention received";
+    },
+    async processEvent(event) {
+      const {
+        type: msgType,
+        subtype,
+        bot_id: botId,
+        text,
+      } = event;
+
+      if (msgType !== "message") {
+        console.log(`Ignoring event with unexpected type "${msgType}"`);
+        return;
+      }
+
+      // 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!!
+      if (subtype && !constants.ALLOWED_SUBTYPES.includes(subtype)) {
+        console.log(`Ignoring message with subtype. "${subtype}"`);
+        return;
+      }
+
+      if ((this.ignoreBot) && (subtype === constants.SUBTYPE.BOT_MESSAGE || botId)) {
+        return;
+      }
+
+      let emitEvent = false;
+      if (text.indexOf(this.keyword) !== -1) {
+        emitEvent = true;
+      } else if (subtype === constants.SUBTYPE.PD_HISTORY_MESSAGE) {
+        emitEvent = true;
+      }
+
+      if (emitEvent) {
+        return event;
+      }
+    },
+  },
+  sampleEmit,
+};