slack/slack-testing.js

Slack API client written in JS

(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.slack = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){

},{}],2:[function(require,module,exports){
var api = require('./api.json')

/**
 * reads api.json and generates a matching javascript object
 * the leaf nodes bind the method name to the passed in exec function
 */
module.exports = function _bind(ns, exec) {

  // walks the generated api.json keys dynamically constructing the client
  Object.keys(api).forEach(key=> {

    // each key is namespaced so we break up into an array to work with 
    // example: api.test --> ['api', 'test']
    var parts = key.split('.')

    // then we get the root part of the namespace
    // example: 'api'
    var root = parts.shift() 
  
    // initialize the root namespace object if it wasn't already
    var init = typeof ns[root] === 'undefined'
    if (init) {
      ns[root] = {} 
    }

    // walks the remaining namespace parts assigning the _exec function at the end
    ;(function _iterator(o) {
      var bit = parts.shift()
      var last = parts.length === 0
      if (last) {
        o[bit] = exec.bind({}, key)
      }
      else {
        var init = typeof o[bit] === 'undefined'
        if (init) {
          o[bit] = {}
        }
        // keep iterating
        _iterator(o[bit])
      }
    })(ns[root])
  })

  return ns
}

},{"./api.json":7}],3:[function(require,module,exports){
let validate = require('./_validate')
let origin = require('./_origin')
let encode = encodeURIComponent
let serialize = o=> Object.keys(o).map(k=> encode(k) + '=' + encode(o[k])).join('&')

/**
 * returns a promise if callback isn't defined; _exec is the actual impl
 */
module.exports = function exec(url, params, callback) {
  if (!callback) {
    return new Promise(function(resolve, reject) {
      _exec(url, params, function __exec(err, res) {
        if (err) {
          reject(err)
        }
        else { 
          resolve(res)
        }
      })
    })
  }
  else {
    _exec(url, params, callback)
  }
}

async function _exec(url, params, callback) {
  try {
    // validates the params against api.json
    var err = validate(url, params)
    if (err) throw err

    // stringify any objects under keys since form 
    // is posted as application/x-www-form-urlencoded
    Object.keys(params).forEach(function (key) {
      if (typeof params[key] === 'object') {
        params[key] = JSON.stringify(params[key])
      }
    })

    var opts = {
      method: 'POST', 
      headers: new Headers({
        'Content-Type': 'application/x-www-form-urlencoded'
      }),
      body: serialize(params)
    }

    var res = await fetch(`${origin}/api/${url}`, opts)
    var json = await res.json()

    if (json.error) {
      var e = Error(json.error)
      if (json.response_metadata && json.response_metadata.messages) {
        e.messages = json.response_metadata.messages
      }
      callback(e)
    }
    else if (res.status === 429) {
      var e = Error('ratelimited')
      e.retry = res.headers.get('retry-after')
      callback(e)
    }
    else {
      callback(null, json)
    }
  }
  catch(e) {
    callback(e)
  }
}

},{"./_origin":5,"./_validate":6}],4:[function(require,module,exports){
var bind = require('./_bind')
var exec = require('./_exec')
var electronExec = require('./_exec-electron')

/** 
 * factory returns a new instance of Slack
 * 
 * things to understand:
 *
 * - this function is the root object exported 
 * - can be a constuctor for creating oo style instances of Slack 
 * - requires named params to allow for future flexability in the function sig
 * - all methods have token pre applied
 * - all methods either accept a callback or return a promise
 */
module.exports = function factory(xxx) {
  
  // allow for empty params
  if (!xxx) xxx = {}

  // override exec to use electron.net via explicit opt-in
  if (xxx.useElectronNet) {
    exec = electronExec(xxx)
  }

  // Slack instance applies the token param to all the api methods
  class Slack {
    constructor() {
      function _execWithToken(method, params={}, callback) {
        params.token = params && params.token || xxx.token
        return exec(method, params, callback)
      }
      // bind applies the above method to this obj
      // bind also returns all methods promisified
      bind(this, _execWithToken)
    }
  }

  return new Slack
}

},{"./_bind":2,"./_exec":3,"./_exec-electron":1}],5:[function(require,module,exports){
var origin = 'https://slack.com'

// allow configuring the url if steno is running on a non-standard port/host
if (false) {
  origin = false
}

module.exports = origin

},{}],6:[function(require,module,exports){
var api = require('./api.json')

module.exports = function validate(method, params) {
  // get all the requried params for this method
  let required = api[method]
  // collect any missing params
  let missing = required.filter(param=> typeof params[param] === 'undefined')
  // optimistic: assume the best but have a plan for the worst
  return missing.length? Error(`${method} missing params: ${missing.join(', ')}`) : false
}

},{"./api.json":7}],7:[function(require,module,exports){
module.exports={
  "api.test": [],
  "apps.permissions.info": [
    "token"
  ],
  "apps.permissions.request": [
    "token",
    "scopes",
    "trigger_id"
  ],
  "auth.revoke": [
    "token"
  ],
  "auth.test": [
    "token"
  ],
  "bots.info": [
    "token"
  ],
  "channels.archive": [
    "token",
    "channel"
  ],
  "channels.create": [
    "token",
    "name"
  ],
  "channels.history": [
    "token",
    "channel"
  ],
  "channels.info": [
    "token",
    "channel"
  ],
  "channels.invite": [
    "token",
    "channel",
    "user"
  ],
  "channels.join": [
    "token",
    "name"
  ],
  "channels.kick": [
    "token",
    "channel",
    "user"
  ],
  "channels.leave": [
    "token",
    "channel"
  ],
  "channels.list": [
    "token"
  ],
  "channels.mark": [
    "token",
    "channel",
    "ts"
  ],
  "channels.rename": [
    "token",
    "channel",
    "name"
  ],
  "channels.replies": [
    "token",
    "channel",
    "thread_ts"
  ],
  "channels.setPurpose": [
    "token",
    "channel",
    "purpose"
  ],
  "channels.setTopic": [
    "token",
    "channel",
    "topic"
  ],
  "channels.unarchive": [
    "token",
    "channel"
  ],
  "chat.delete": [
    "token",
    "channel",
    "ts"
  ],
  "chat.getPermalink": [
    "token",
    "channel",
    "message_ts"
  ],
  "chat.meMessage": [
    "token",
    "channel",
    "text"
  ],
  "chat.postEphemeral": [
    "token",
    "channel",
    "text",
    "user"
  ],
  "chat.postMessage": [
    "token",
    "channel",
    "text"
  ],
  "chat.unfurl": [
    "token",
    "channel",
    "ts",
    "unfurls"
  ],
  "chat.update": [
    "token",
    "channel",
    "text",
    "ts"
  ],
  "conversations.archive": [
    "token",
    "channel"
  ],
  "conversations.close": [
    "token",
    "channel"
  ],
  "conversations.create": [
    "token",
    "name"
  ],
  "conversations.history": [
    "token",
    "channel"
  ],
  "conversations.info": [
    "token",
    "channel"
  ],
  "conversations.invite": [
    "token",
    "channel",
    "users"
  ],
  "conversations.join": [
    "token",
    "channel"
  ],
  "conversations.kick": [
    "token",
    "channel",
    "user"
  ],
  "conversations.leave": [
    "token",
    "channel"
  ],
  "conversations.list": [
    "token"
  ],
  "conversations.members": [
    "token",
    "channel"
  ],
  "conversations.open": [
    "token"
  ],
  "conversations.rename": [
    "token",
    "channel",
    "name"
  ],
  "conversations.replies": [
    "token",
    "channel",
    "ts"
  ],
  "conversations.setPurpose": [
    "token",
    "channel",
    "purpose"
  ],
  "conversations.setTopic": [
    "token",
    "channel",
    "topic"
  ],
  "conversations.unarchive": [
    "token",
    "channel"
  ],
  "dialog.open": [
    "token",
    "dialog",
    "trigger_id"
  ],
  "dnd.endDnd": [
    "token"
  ],
  "dnd.endSnooze": [
    "token"
  ],
  "dnd.info": [
    "token"
  ],
  "dnd.setSnooze": [
    "token",
    "num_minutes"
  ],
  "dnd.teamInfo": [
    "token"
  ],
  "emoji.list": [
    "token"
  ],
  "files.comments.add": [
    "token",
    "comment",
    "file"
  ],
  "files.comments.delete": [
    "token",
    "file",
    "id"
  ],
  "files.comments.edit": [
    "token",
    "comment",
    "file",
    "id"
  ],
  "files.delete": [
    "token",
    "file"
  ],
  "files.info": [
    "token",
    "file"
  ],
  "files.list": [
    "token"
  ],
  "files.revokePublicURL": [
    "token",
    "file"
  ],
  "files.sharedPublicURL": [
    "token",
    "file"
  ],
  "files.upload": [
    "token"
  ],
  "groups.archive": [
    "token",
    "channel"
  ],
  "groups.create": [
    "token",
    "name"
  ],
  "groups.createChild": [
    "token",
    "channel"
  ],
  "groups.history": [
    "token",
    "channel"
  ],
  "groups.info": [
    "token",
    "channel"
  ],
  "groups.invite": [
    "token",
    "channel",
    "user"
  ],
  "groups.kick": [
    "token",
    "channel",
    "user"
  ],
  "groups.leave": [
    "token",
    "channel"
  ],
  "groups.list": [
    "token"
  ],
  "groups.mark": [
    "token",
    "channel",
    "ts"
  ],
  "groups.open": [
    "token",
    "channel"
  ],
  "groups.rename": [
    "token",
    "channel",
    "name"
  ],
  "groups.replies": [
    "token",
    "channel",
    "thread_ts"
  ],
  "groups.setPurpose": [
    "token",
    "channel",
    "purpose"
  ],
  "groups.setTopic": [
    "token",
    "channel",
    "topic"
  ],
  "groups.unarchive": [
    "token",
    "channel"
  ],
  "im.close": [
    "token",
    "channel"
  ],
  "im.history": [
    "token",
    "channel"
  ],
  "im.list": [
    "token"
  ],
  "im.mark": [
    "token",
    "channel",
    "ts"
  ],
  "im.open": [
    "token",
    "user"
  ],
  "im.replies": [
    "token",
    "channel",
    "thread_ts"
  ],
  "migration.exchange": [
    "token",
    "users"
  ],
  "mpim.close": [
    "token",
    "channel"
  ],
  "mpim.history": [
    "token",
    "channel"
  ],
  "mpim.list": [
    "token"
  ],
  "mpim.mark": [
    "token",
    "channel",
    "ts"
  ],
  "mpim.open": [
    "token",
    "users"
  ],
  "mpim.replies": [
    "token",
    "channel",
    "thread_ts"
  ],
  "oauth.access": [
    "client_id",
    "client_secret",
    "code"
  ],
  "oauth.token": [
    "client_id",
    "client_secret",
    "code"
  ],
  "pins.add": [
    "token",
    "channel"
  ],
  "pins.list": [
    "token",
    "channel"
  ],
  "pins.remove": [
    "token",
    "channel"
  ],
  "reactions.add": [
    "token",
    "name"
  ],
  "reactions.get": [
    "token"
  ],
  "reactions.list": [
    "token"
  ],
  "reactions.remove": [
    "token",
    "name"
  ],
  "reminders.add": [
    "token",
    "text",
    "time"
  ],
  "reminders.complete": [
    "token",
    "reminder"
  ],
  "reminders.delete": [
    "token",
    "reminder"
  ],
  "reminders.info": [
    "token",
    "reminder"
  ],
  "reminders.list": [
    "token"
  ],
  "rtm.connect": [
    "token"
  ],
  "rtm.start": [
    "token"
  ],
  "search.all": [
    "token",
    "query"
  ],
  "search.files": [
    "token",
    "query"
  ],
  "search.messages": [
    "token",
    "query"
  ],
  "stars.add": [
    "token"
  ],
  "stars.list": [
    "token"
  ],
  "stars.remove": [
    "token"
  ],
  "team.accessLogs": [
    "token"
  ],
  "team.billableInfo": [
    "token"
  ],
  "team.info": [
    "token"
  ],
  "team.integrationLogs": [
    "token"
  ],
  "team.profile.get": [
    "token"
  ],
  "usergroups.create": [
    "token",
    "name"
  ],
  "usergroups.disable": [
    "token",
    "usergroup"
  ],
  "usergroups.enable": [
    "token",
    "usergroup"
  ],
  "usergroups.list": [
    "token"
  ],
  "usergroups.update": [
    "token",
    "usergroup"
  ],
  "usergroups.users.list": [
    "token",
    "usergroup"
  ],
  "usergroups.users.update": [
    "token",
    "usergroup",
    "users"
  ],
  "users.deletePhoto": [
    "token"
  ],
  "users.getPresence": [
    "token",
    "user"
  ],
  "users.identity": [
    "token"
  ],
  "users.info": [
    "token",
    "user"
  ],
  "users.list": [
    "token"
  ],
  "users.lookupByEmail": [
    "token",
    "email"
  ],
  "users.setActive": [
    "token"
  ],
  "users.setPhoto": [
    "token",
    "image"
  ],
  "users.setPresence": [
    "token",
    "presence"
  ],
  "users.profile.get": [
    "token"
  ],
  "users.profile.set": [
    "token"
  ]
}

},{}],8:[function(require,module,exports){
let bind = require('./src/_bind')
let exec = require('./src/_exec')
let factory = require('./src/_factory')

/**
 * bind accepts an object, in this case the factory function, and
 * applies exec to the Slack API methods as defined in api.json
 */
module.exports = bind(factory, exec)

},{"./src/_bind":2,"./src/_exec":3,"./src/_factory":4}]},{},[8])(8)
});