index.ts

"use strict";

import WebSocket, { EventEmitter } from "ws";
import fetch from "node-fetch";

const _ = require("lodash");
const extend = require("extend");
const { setWsHeartbeat } = require("ws-heartbeat/client");

export default class Bot extends EventEmitter {
  private token: string;
  private name: string;
  private channels: any[] = [];
  private users: any[] = [];
  private groups: any[] = [];
  private ims: any[] = [];

  public ws: WebSocket | null = null;
  public retryAfter: number | null = null;

  constructor(params?: any) {
    super(params);
    this.token = params.token;
    this.name = params.name;

    console.assert(params.token, "token must be defined");
  }

  public async connect() {
    const data = await this._api("rtm.connect");

    if (!data) {
      this.emit("error", new Error(data.error ? data.error : data));
    }

    this.ws = new WebSocket(data.url);
    setWsHeartbeat(this.ws, '{ "kind": "ping" }');
    this.emit("start");

    this.ws.on("error", (data: any) => {
      this.emit("error", new Error(data?.error ?? data));
    });

    this.ws.on("open", (data: any) => {
      this.emit("open", data);
    });

    this.ws.on("close", (data) => {
      this.emit("close", data);
    });

    this.ws.on("message", (data) => {
      try {
        this.emit("message", JSON.parse(data.toString()));
      } catch (e) {
        console.log(e);
      }
    });
  }

  public async getChannels() {
    if (this.channels.length) {
      return { channels: this.channels };
    }

    return await this._api("conversations.list");
  }

  public async getUsers() {
    if (this.users.length) {
      return { members: this.users };
    }

    return await this._api("users.list");
  }

  public async getGroups() {
    if (this.groups.length) {
      return { groups: this.groups };
    }

    return await this._api("conversations.list");
  }

  public async getUser(name: string) {
    const data = await this.getUsers();
    const res = _.find(data.members, { name: name });

    console.assert(res, "user not found");
    return res;
  }

  public async getChannel(name: string) {
    const data = await this.getChannels();
    const res = _.find(data.channels, { name: name });

    console.assert(res, "channel not found");
    return res;
  }

  public async getGroup(name: string) {
    const data = await this.getGroups();
    const res = _.find(data.groups, { name: name });

    console.assert(res, "group not found");
    return res;
  }

  public async getUserById(id: string) {
    const data = await this.getUsers();
    const res = _.find(data.members, { id: id });

    console.assert(res, "user not found");
    return res;
  }

  public async getChannelById(id: string) {
    const data = await this.getChannels();
    const res = _.find(data.channels, { id: id });

    console.assert(res, "channel not found");
    return res;
  }

  public async getGroupById(id: string) {
    const data = await this.getGroups();
    const res = _.find(data.groups, { id: id });

    console.assert(res, "group not found");
    return res;
  }

  public async getChannelId(name: string) {
    const channel = await this.getChannel(name);
    return channel.id;
  }

  public async getGroupId(name: string) {
    const group = await this.getGroup(name);
    return group.id;
  }

  public async getUserId(name: string) {
    const user = await this.getUser(name);
    return user.id;
  }

  public async getUserByEmail(email: string) {
    const data = await this.getUsers();
    return _.find(data.members, { profile: { email: email } });
  }

  public async getChatId(name: string) {
    const user = await this.getUser(name);
    const chatId = _.find(this.ims, { user: user.id });
    const data = (chatId && chatId.id) || this.openIm(user.id);
    return typeof data === "string" ? data : data.channel.id;
  }

  public async openIm(userId: string) {
    return await this._api("conversations.open", { user: userId });
  }

  public async getImChannels() {
    if (this.ims.length) {
      return { ims: this.ims };
    }

    return await this._api("conversations.list");
  }

  public async postEphemeral(
    id: string,
    user: string,
    text: string,
    params: any
  ) {
    params = extend(
      {
        text: text,
        channel: id,
        user: user,
        username: this.name,
      },
      params || {}
    );

    return await this._api("chat.postEphemeral", params);
  }

  public async postMessage<T = any>(id: string, text: string, params: any) {
    params = extend(
      {
        text: text,
        channel: id,
        username: this.name,
      },
      params || {}
    );

    return await this._api<T>("chat.postMessage", params);
  }

  public async updateMessage(
    id: string,
    ts: string,
    text: string,
    params: any
  ) {
    params = extend(
      {
        ts: ts,
        channel: id,
        username: this.name,
        text: text,
      },
      params || {}
    );

    return await this._api("chat.update", params);
  }

  public async postMessageToUser(
    name: string,
    text: string,
    params?: any,
    cb?: (value: any) => void
  ) {
    return await this._post(
      (params || {}).slackbot ? "slackbot" : "user",
      name,
      text,
      params,
      cb
    );
  }

  public async postMessageToChannel(
    name: string,
    text: string,
    params?: any,
    cb?: (value: any) => void
  ) {
    return await this._post("channel", name, text, params, cb);
  }

  public async postMessageToGroup(
    name: string,
    text: string,
    params?: any,
    cb?: (value: any) => void
  ) {
    return await this._post("group", name, text, params, cb);
  }

  private async _post(
    type: "group" | "channel" | "user" | "slackbot",
    name: string,
    text: string,
    params?: any | null,
    cb?: (value: any) => void
  ) {
    const method = {
      group: "getGroupId",
      channel: "getChannelId",
      user: "getChatId",
      slackbot: "getUserId",
    }[type];

    const itemId = await (this as any)[method](name);
    const data = await this.postMessage(itemId, text, params);

    return cb?.(data._value);
  }

  public async postTo(
    name: string,
    text: string,
    params: any,
    cb: (value: any) => void
  ) {
    const data = await Promise.all([
      this.getChannels(),
      this.getUsers(),
      this.getGroups(),
    ]);

    name = this._cleanName(name);
    const all = [].concat(data[0].channels, data[1].members, data[2].groups);
    const result = _.find(all, { name: name });

    console.assert(result, "wrong name");

    if (result["is_channel"]) {
      return await this.postMessageToChannel(name, text, params, cb);
    } else if (result["is_group"]) {
      return await this.postMessageToGroup(name, text, params, cb);
    } else {
      return await this.postMessageToUser(name, text, params, cb);
    }
  }

  private _cleanName(name: string) {
    if (typeof name !== "string") {
      return name;
    }

    const firstCharacter = name.charAt(0);
    if (firstCharacter === "#" || firstCharacter === "@") {
      name = name.slice(1);
    }
    return name;
  }

  private _preprocessParams(params?: any) {
    const searchParams = new URLSearchParams();
    searchParams.append("token", this.token);

    if (!params) {
      return searchParams;
    }

    for (const [key, value] of Object.entries(params)) {
      if (typeof value === "object") {
        searchParams.append(key, JSON.stringify(value));
        continue;
      }

      searchParams.append(key, value as string);
    }

    return searchParams;
  }

  private async _api<T extends { ok?: boolean } & any = any>(
    methodName: string,
    params?: any
  ): Promise<T> {
    const response = await fetch(`https://slack.com/api/${methodName}`, {
      method: "POST",
      body: this._preprocessParams(params),
    });

    // Keep track of last retry so we can handle accordingly if needed
    this.retryAfter = response.headers.has("retry-after")
      ? Number(response.headers.get("retry-after"))
      : null;

    const data = await response.json();

    /**
     * Response data always contain a top-level boolean property ok,
     * indicating success or failure
     */
    if (!response.ok || !data.ok) {
      throw data;
    }

    return data as T;
  }
}