cloudstructs 0.9.11 → 0.9.13

package/node_modules/@slack/web-api/dist/WebClient.js

@@ -22,12 +22,22 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
 var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
     if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
     var g = generator.apply(thisArg, _arguments || []), i, q = [];
-    return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
-    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+    return i = {}, verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
     function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
     function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
     function fulfill(value) { resume("next", value); }
@@ -46,26 +56,28 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildThreadTsWarningMessage = exports.WebClient = exports.WebClientEvent = void 0;
-const querystring_1 = require("querystring");
 const path_1 = require("path");
-const zlib_1 = __importDefault(require("zlib"));
+const querystring_1 = require("querystring");
 const util_1 = require("util");
-const is_stream_1 = __importDefault(require("is-stream"));
-const p_queue_1 = __importDefault(require("p-queue"));
-const p_retry_1 = __importStar(require("p-retry"));
+const zlib_1 = __importDefault(require("zlib"));
 const axios_1 = __importDefault(require("axios"));
 const form_data_1 = __importDefault(require("form-data"));
 const is_electron_1 = __importDefault(require("is-electron"));
-const methods_1 = require("./methods");
-const instrument_1 = require("./instrument");
+const is_stream_1 = __importDefault(require("is-stream"));
+const p_queue_1 = __importDefault(require("p-queue"));
+const p_retry_1 = __importStar(require("p-retry"));
 const errors_1 = require("./errors");
+const file_upload_1 = require("./file-upload");
+const helpers_1 = __importDefault(require("./helpers"));
+const instrument_1 = require("./instrument");
 const logger_1 = require("./logger");
+const methods_1 = require("./methods");
 const retry_policies_1 = require("./retry-policies");
-const helpers_1 = __importDefault(require("./helpers"));
-const file_upload_1 = require("./file-upload");
 /*
  * Helpers
  */
+// Props on axios default headers object to ignore when retrieving full list of actual headers sent in any HTTP requests
+const axiosHeaderPropsToIgnore = ['delete', 'common', 'get', 'put', 'head', 'post', 'link', 'patch', 'purge', 'unlink', 'options'];
 const defaultFilename = 'Untitled';
 const defaultPageSize = 200;
 const noopPageReducer = () => undefined;
@@ -74,7 +86,7 @@ var WebClientEvent;
     // TODO: safe to rename this to conform to PascalCase enum type naming convention?
     // eslint-disable-next-line @typescript-eslint/naming-convention
     WebClientEvent["RATE_LIMITED"] = "rate_limited";
-})(WebClientEvent = exports.WebClientEvent || (exports.WebClientEvent = {}));
+})(WebClientEvent || (exports.WebClientEvent = WebClientEvent = {}));
 /**
  * A client for Slack's Web API
  *
@@ -85,16 +97,18 @@ class WebClient extends methods_1.Methods {
     /**
      * @param token - An API token to authenticate/authorize with Slack (usually start with `xoxp`, `xoxb`)
      */
-    constructor(token, { slackApiUrl = 'https://slack.com/api/', logger = undefined, logLevel = undefined, maxRequestConcurrency = 100, retryConfig = retry_policies_1.tenRetriesInAboutThirtyMinutes, agent = undefined, tls = undefined, timeout = 0, rejectRateLimitedCalls = false, headers = {}, teamId = undefined, } = {}) {
+    constructor(token, { slackApiUrl = 'https://slack.com/api/', logger = undefined, logLevel = undefined, maxRequestConcurrency = 100, retryConfig = retry_policies_1.tenRetriesInAboutThirtyMinutes, agent = undefined, tls = undefined, timeout = 0, rejectRateLimitedCalls = false, headers = {}, teamId = undefined, attachOriginalToWebAPIRequestError = true, } = {}) {
         super();
         this.token = token;
         this.slackApiUrl = slackApiUrl;
         this.retryConfig = retryConfig;
+        // eslint-disable-next-line new-cap
         this.requestQueue = new p_queue_1.default({ concurrency: maxRequestConcurrency });
         // NOTE: may want to filter the keys to only those acceptable for TLS options
         this.tlsConfig = tls !== undefined ? tls : {};
         this.rejectRateLimitedCalls = rejectRateLimitedCalls;
         this.teamId = teamId;
+        this.attachOriginalToWebAPIRequestError = attachOriginalToWebAPIRequestError;
         // Logging
         if (typeof logger !== 'undefined') {
             this.logger = logger;
@@ -111,11 +125,12 @@ class WebClient extends methods_1.Methods {
         this.axios = axios_1.default.create({
             timeout,
             baseURL: slackApiUrl,
+            // eslint-disable-next-line @typescript-eslint/naming-convention
             headers: (0, is_electron_1.default)() ? headers : Object.assign({ 'User-Agent': (0, instrument_1.getUserAgent)() }, headers),
             httpAgent: agent,
             httpsAgent: agent,
             transformRequest: [this.serializeApiCallOptions.bind(this)],
-            validateStatus: () => true,
+            validateStatus: () => true, // all HTTP status codes should result in a resolved promise (as opposed to only 2xx)
             maxRedirects: 0,
             // disabling axios' automatic proxy support:
             // axios would read from envvars to configure a proxy automatically, but it doesn't support TLS destinations.
@@ -129,67 +144,67 @@ class WebClient extends methods_1.Methods {
     }
     /**
      * Generic method for calling a Web API method
-     *
      * @param method - the Web API method to call {@link https://api.slack.com/methods}
      * @param options - options
      */
-    async apiCall(method, options = {}) {
-        this.logger.debug(`apiCall('${method}') start`);
-        warnDeprecations(method, this.logger);
-        warnIfFallbackIsMissing(method, this.logger, options);
-        warnIfThreadTsIsNotString(method, this.logger, options);
-        if (typeof options === 'string' || typeof options === 'number' || typeof options === 'boolean') {
-            throw new TypeError(`Expected an options argument but instead received a ${typeof options}`);
-        }
-        (0, file_upload_1.warnIfNotUsingFilesUploadV2)(method, this.logger);
-        if (method === 'files.uploadV2')
-            return this.filesUploadV2(options);
-        const headers = {};
-        if (options.token)
-            headers.Authorization = `Bearer ${options.token}`;
-        const response = await this.makeRequest(method, Object.assign({ team_id: this.teamId }, options), headers);
-        const result = await this.buildResult(response);
-        this.logger.debug(`http request result: ${JSON.stringify(result)}`);
-        // log warnings in response metadata
-        if (result.response_metadata !== undefined && result.response_metadata.warnings !== undefined) {
-            result.response_metadata.warnings.forEach(this.logger.warn.bind(this.logger));
-        }
-        // log warnings and errors in response metadata messages
-        // related to https://api.slack.com/changelog/2016-09-28-response-metadata-is-on-the-way
-        if (result.response_metadata !== undefined && result.response_metadata.messages !== undefined) {
-            result.response_metadata.messages.forEach((msg) => {
-                const errReg = /\[ERROR\](.*)/;
-                const warnReg = /\[WARN\](.*)/;
-                if (errReg.test(msg)) {
-                    const errMatch = msg.match(errReg);
-                    if (errMatch != null) {
-                        this.logger.error(errMatch[1].trim());
+    apiCall(method, options = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.debug(`apiCall('${method}') start`);
+            warnDeprecations(method, this.logger);
+            warnIfFallbackIsMissing(method, this.logger, options);
+            warnIfThreadTsIsNotString(method, this.logger, options);
+            if (typeof options === 'string' || typeof options === 'number' || typeof options === 'boolean') {
+                throw new TypeError(`Expected an options argument but instead received a ${typeof options}`);
+            }
+            (0, file_upload_1.warnIfNotUsingFilesUploadV2)(method, this.logger);
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore
+            if (method === 'files.uploadV2')
+                return this.filesUploadV2(options);
+            const headers = {};
+            if (options.token)
+                headers.Authorization = `Bearer ${options.token}`;
+            const response = yield this.makeRequest(method, Object.assign({ team_id: this.teamId }, options), headers);
+            const result = yield this.buildResult(response);
+            this.logger.debug(`http request result: ${JSON.stringify(result)}`);
+            // log warnings in response metadata
+            if (result.response_metadata !== undefined && result.response_metadata.warnings !== undefined) {
+                result.response_metadata.warnings.forEach(this.logger.warn.bind(this.logger));
+            }
+            // log warnings and errors in response metadata messages
+            // related to https://api.slack.com/changelog/2016-09-28-response-metadata-is-on-the-way
+            if (result.response_metadata !== undefined && result.response_metadata.messages !== undefined) {
+                result.response_metadata.messages.forEach((msg) => {
+                    const errReg = /\[ERROR\](.*)/;
+                    const warnReg = /\[WARN\](.*)/;
+                    if (errReg.test(msg)) {
+                        const errMatch = msg.match(errReg);
+                        if (errMatch != null) {
+                            this.logger.error(errMatch[1].trim());
+                        }
                     }
-                }
-                else if (warnReg.test(msg)) {
-                    const warnMatch = msg.match(warnReg);
-                    if (warnMatch != null) {
-                        this.logger.warn(warnMatch[1].trim());
+                    else if (warnReg.test(msg)) {
+                        const warnMatch = msg.match(warnReg);
+                        if (warnMatch != null) {
+                            this.logger.warn(warnMatch[1].trim());
+                        }
                     }
-                }
-            });
-        }
-        // If result's content is gzip, "ok" property is not returned with successful response
-        // TODO: look into simplifying this code block to only check for the second condition
-        // if an { ok: false } body applies for all API errors
-        if (!result.ok && (response.headers['content-type'] !== 'application/gzip')) {
-            throw (0, errors_1.platformErrorFromResult)(result);
-        }
-        else if ('ok' in result && result.ok === false) {
-            throw (0, errors_1.platformErrorFromResult)(result);
-        }
-        this.logger.debug(`apiCall('${method}') end`);
-        return result;
+                });
+            }
+            // If result's content is gzip, "ok" property is not returned with successful response
+            // TODO: look into simplifying this code block to only check for the second condition
+            // if an { ok: false } body applies for all API errors
+            if (!result.ok && (response.headers['content-type'] !== 'application/gzip')) {
+                throw (0, errors_1.platformErrorFromResult)(result);
+            }
+            else if ('ok' in result && result.ok === false) {
+                throw (0, errors_1.platformErrorFromResult)(result);
+            }
+            this.logger.debug(`apiCall('${method}') end`);
+            return result;
+        });
     }
     paginate(method, options, shouldStop, reduce) {
-        if (!methods_1.cursorPaginationEnabledMethods.has(method)) {
-            this.logger.warn(`paginate() called with method ${method}, which is not known to be cursor pagination enabled.`);
-        }
         const pageSize = (() => {
             if (options !== undefined && typeof options.limit === 'number') {
                 const { limit } = options;
@@ -224,14 +239,14 @@ class WebClient extends methods_1.Methods {
         }
         const pageReducer = (reduce !== undefined) ? reduce : noopPageReducer;
         let index = 0;
-        return (async () => {
+        return (() => __awaiter(this, void 0, void 0, function* () {
             // Unroll the first iteration of the iterator
             // This is done primarily because in order to satisfy the type system, we need a variable that is typed as A
             // (shown as accumulator before), but before the first iteration all we have is a variable typed A | undefined.
             // Unrolling the first iteration allows us to deal with undefined as a special case.
             var _a, e_1, _b, _c;
             const pageIterator = generatePages.call(this);
-            const firstIteratorResult = await pageIterator.next(undefined);
+            const firstIteratorResult = yield pageIterator.next(undefined);
             // Assumption: there will always be at least one result in a paginated API request
             // if (firstIteratorResult.done) { return; }
             const firstPage = firstIteratorResult.value;
@@ -243,33 +258,27 @@ class WebClient extends methods_1.Methods {
             try {
                 // Continue iteration
                 // eslint-disable-next-line no-restricted-syntax
-                for (var _d = true, pageIterator_1 = __asyncValues(pageIterator), pageIterator_1_1; pageIterator_1_1 = await pageIterator_1.next(), _a = pageIterator_1_1.done, !_a;) {
+                for (var _d = true, pageIterator_1 = __asyncValues(pageIterator), pageIterator_1_1; pageIterator_1_1 = yield pageIterator_1.next(), _a = pageIterator_1_1.done, !_a; _d = true) {
                     _c = pageIterator_1_1.value;
                     _d = false;
-                    try {
-                        const page = _c;
-                        accumulator = pageReducer(accumulator, page, index);
-                        if (shouldStop(page)) {
-                            return accumulator;
-                        }
-                        index += 1;
-                    }
-                    finally {
-                        _d = true;
+                    const page = _c;
+                    accumulator = pageReducer(accumulator, page, index);
+                    if (shouldStop(page)) {
+                        return accumulator;
                     }
+                    index += 1;
                 }
             }
             catch (e_1_1) { e_1 = { error: e_1_1 }; }
             finally {
                 try {
-                    if (!_d && !_a && (_b = pageIterator_1.return)) await _b.call(pageIterator_1);
+                    if (!_d && !_a && (_b = pageIterator_1.return)) yield _b.call(pageIterator_1);
                 }
                 finally { if (e_1) throw e_1.error; }
             }
             return accumulator;
-        })();
+        }))();
     }
-    /* eslint-disable no-trailing-spaces */
     /**
      * This wrapper method provides an easy way to upload files using the following endpoints:
      *
@@ -281,24 +290,25 @@ class WebClient extends methods_1.Methods {
      * URLs returned from step 1 (e.g. https://files.slack.com/upload/v1/...\")
      *
      * **#3**: Complete uploads {@link https://api.slack.com/methods/files.completeUploadExternal files.completeUploadExternal}
-     *
      * @param options
      */
-    async filesUploadV2(options) {
-        this.logger.debug('files.uploadV2() start');
-        // 1
-        const fileUploads = await this.getAllFileUploads(options);
-        const fileUploadsURLRes = await this.fetchAllUploadURLExternal(fileUploads);
-        // set the upload_url and file_id returned from Slack
-        fileUploadsURLRes.forEach((res, idx) => {
-            fileUploads[idx].upload_url = res.upload_url;
-            fileUploads[idx].file_id = res.file_id;
+    filesUploadV2(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.debug('files.uploadV2() start');
+            // 1
+            const fileUploads = yield this.getAllFileUploads(options);
+            const fileUploadsURLRes = yield this.fetchAllUploadURLExternal(fileUploads);
+            // set the upload_url and file_id returned from Slack
+            fileUploadsURLRes.forEach((res, idx) => {
+                fileUploads[idx].upload_url = res.upload_url;
+                fileUploads[idx].file_id = res.file_id;
+            });
+            // 2
+            yield this.postFileUploadsToExternalURL(fileUploads, options);
+            // 3
+            const completion = yield this.completeFileUploads(fileUploads);
+            return { ok: true, files: completion };
         });
-        // 2
-        await this.postFileUploadsToExternalURL(fileUploads, options);
-        // 3
-        const completion = await this.completeFileUploads(fileUploads);
-        return { ok: true, files: completion };
     }
     /**
      * For each file submitted with this method, submits filenames
@@ -306,147 +316,173 @@ class WebClient extends methods_1.Methods {
      * which to send the file data to and an id for the file
      * @param fileUploads
      */
-    async fetchAllUploadURLExternal(fileUploads) {
-        return Promise.all(fileUploads.map((upload) => {
-            /* eslint-disable @typescript-eslint/consistent-type-assertions */
-            const options = {
-                filename: upload.filename,
-                length: upload.length,
-                alt_text: upload.alt_text,
-                snippet_type: upload.snippet_type,
-            };
-            return this.files.getUploadURLExternal(options);
-        }));
+    fetchAllUploadURLExternal(fileUploads) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Promise.all(fileUploads.map((upload) => {
+                /* eslint-disable @typescript-eslint/consistent-type-assertions */
+                const options = {
+                    filename: upload.filename,
+                    length: upload.length,
+                    alt_text: upload.alt_text,
+                    snippet_type: upload.snippet_type,
+                };
+                if ('token' in upload) {
+                    options.token = upload.token;
+                }
+                return this.files.getUploadURLExternal(options);
+            }));
+        });
     }
     /**
      * Complete uploads.
      * @param fileUploads
      * @returns
      */
-    async completeFileUploads(fileUploads) {
-        const toComplete = Object.values((0, file_upload_1.getAllFileUploadsToComplete)(fileUploads));
-        return Promise.all(toComplete.map((job) => this.files.completeUploadExternal(job)));
+    completeFileUploads(fileUploads) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const toComplete = Object.values((0, file_upload_1.getAllFileUploadsToComplete)(fileUploads));
+            return Promise.all(toComplete.map((job) => this.files.completeUploadExternal(job)));
+        });
     }
     /**
      * for each returned file upload URL, upload corresponding file
      * @param fileUploads
      * @returns
      */
-    async postFileUploadsToExternalURL(fileUploads, options) {
-        return Promise.all(fileUploads.map(async (upload) => {
-            const { upload_url, file_id, filename, data } = upload;
-            // either file or content will be defined
-            const body = data;
-            // try to post to external url
-            if (upload_url) {
-                const headers = {};
-                if (options.token)
-                    headers.Authorization = `Bearer ${options.token}`;
-                const uploadRes = await this.makeRequest(upload_url, {
-                    body,
-                }, headers);
-                if (uploadRes.status !== 200) {
-                    return Promise.reject(Error(`Failed to upload file (id:${file_id}, filename: ${filename})`));
+    postFileUploadsToExternalURL(fileUploads, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Promise.all(fileUploads.map((upload) => __awaiter(this, void 0, void 0, function* () {
+                const { upload_url, file_id, filename, data } = upload;
+                // either file or content will be defined
+                const body = data;
+                // try to post to external url
+                if (upload_url) {
+                    const headers = {};
+                    if (options.token)
+                        headers.Authorization = `Bearer ${options.token}`;
+                    const uploadRes = yield this.makeRequest(upload_url, {
+                        body,
+                    }, headers);
+                    if (uploadRes.status !== 200) {
+                        return Promise.reject(Error(`Failed to upload file (id:${file_id}, filename: ${filename})`));
+                    }
+                    const returnData = { ok: true, body: uploadRes.data };
+                    return Promise.resolve(returnData);
                 }
-                const returnData = { ok: true, body: uploadRes.data };
-                return Promise.resolve(returnData);
-            }
-            return Promise.reject(Error(`No upload url found for file (id: ${file_id}, filename: ${filename}`));
-        }));
+                return Promise.reject(Error(`No upload url found for file (id: ${file_id}, filename: ${filename}`));
+            })));
+        });
     }
     /**
      * @param options All file uploads arguments
      * @returns An array of file upload entries
      */
-    async getAllFileUploads(options) {
-        let fileUploads = [];
-        // add single file data to uploads if file or content exists at the top level
-        if (options.file || options.content) {
-            fileUploads.push(await (0, file_upload_1.getFileUploadJob)(options, this.logger));
-        }
-        // add multiple files data when file_uploads is supplied
-        if (options.file_uploads) {
-            fileUploads = fileUploads.concat(await (0, file_upload_1.getMultipleFileUploadJobs)(options, this.logger));
-        }
-        return fileUploads;
+    getAllFileUploads(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let fileUploads = [];
+            // add single file data to uploads if file or content exists at the top level
+            if ('file' in options || 'content' in options) {
+                fileUploads.push(yield (0, file_upload_1.getFileUploadJob)(options, this.logger));
+            }
+            // add multiple files data when file_uploads is supplied
+            if ('file_uploads' in options) {
+                fileUploads = fileUploads.concat(yield (0, file_upload_1.getMultipleFileUploadJobs)(options, this.logger));
+            }
+            return fileUploads;
+        });
     }
     /**
      * Low-level function to make a single API request. handles queuing, retries, and http-level errors
      */
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    async makeRequest(url, body, headers = {}) {
-        // TODO: better input types - remove any
-        const task = () => this.requestQueue.add(async () => {
-            const requestURL = (url.startsWith('https' || 'http')) ? url : `${this.axios.getUri() + url}`;
-            this.logger.debug(`http request url: ${requestURL}`);
-            this.logger.debug(`http request body: ${JSON.stringify(redact(body))}`);
-            this.logger.debug(`http request headers: ${JSON.stringify(redact(headers))}`);
-            try {
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                const config = Object.assign({ headers }, this.tlsConfig);
-                // admin.analytics.getFile returns a binary response
-                // To be able to parse it, it should be read as an ArrayBuffer
-                if (url.endsWith('admin.analytics.getFile')) {
-                    config.responseType = 'arraybuffer';
-                }
-                const response = await this.axios.post(url, body, config);
-                this.logger.debug('http response received');
-                if (response.status === 429) {
-                    const retrySec = parseRetryHeaders(response);
-                    if (retrySec !== undefined) {
-                        this.emit(WebClientEvent.RATE_LIMITED, retrySec, { url, body });
-                        if (this.rejectRateLimitedCalls) {
-                            throw new p_retry_1.AbortError((0, errors_1.rateLimitedErrorWithDelay)(retrySec));
+    makeRequest(url, body, headers = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // TODO: better input types - remove any
+            const task = () => this.requestQueue.add(() => __awaiter(this, void 0, void 0, function* () {
+                const requestURL = (url.startsWith('https' || 'http')) ? url : `${this.axios.getUri() + url}`;
+                try {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    const config = Object.assign({ headers }, this.tlsConfig);
+                    // admin.analytics.getFile returns a binary response
+                    // To be able to parse it, it should be read as an ArrayBuffer
+                    if (url.endsWith('admin.analytics.getFile')) {
+                        config.responseType = 'arraybuffer';
+                    }
+                    // apps.event.authorizations.list will reject HTTP requests that send token in the body
+                    // TODO: consider applying this change to all methods - though that will require thorough integration testing
+                    if (url.endsWith('apps.event.authorizations.list')) {
+                        // eslint-disable-next-line no-param-reassign
+                        delete body.token;
+                    }
+                    this.logger.debug(`http request url: ${requestURL}`);
+                    this.logger.debug(`http request body: ${JSON.stringify(redact(body))}`);
+                    // compile all headers - some set by default under the hood by axios - that will be sent along
+                    let allHeaders = Object.keys(this.axios.defaults.headers)
+                        .reduce((acc, cur) => {
+                        if (!axiosHeaderPropsToIgnore.includes(cur)) {
+                            acc[cur] = this.axios.defaults.headers[cur];
+                        }
+                        return acc;
+                    }, {});
+                    allHeaders = Object.assign(Object.assign(Object.assign({}, this.axios.defaults.headers.common), allHeaders), headers);
+                    this.logger.debug(`http request headers: ${JSON.stringify(redact(allHeaders))}`);
+                    const response = yield this.axios.post(url, body, config);
+                    this.logger.debug('http response received');
+                    if (response.status === 429) {
+                        const retrySec = parseRetryHeaders(response);
+                        if (retrySec !== undefined) {
+                            this.emit(WebClientEvent.RATE_LIMITED, retrySec, { url, body });
+                            if (this.rejectRateLimitedCalls) {
+                                throw new p_retry_1.AbortError((0, errors_1.rateLimitedErrorWithDelay)(retrySec));
+                            }
+                            this.logger.info(`API Call failed due to rate limiting. Will retry in ${retrySec} seconds.`);
+                            // pause the request queue and then delay the rejection by the amount of time in the retry header
+                            this.requestQueue.pause();
+                            // NOTE: if there was a way to introspect the current RetryOperation and know what the next timeout
+                            // would be, then we could subtract that time from the following delay, knowing that it the next
+                            // attempt still wouldn't occur until after the rate-limit header has specified. an even better
+                            // solution would be to subtract the time from only the timeout of this next attempt of the
+                            // RetryOperation. this would result in the staying paused for the entire duration specified in the
+                            // header, yet this operation not having to pay the timeout cost in addition to that.
+                            yield (0, helpers_1.default)(retrySec * 1000);
+                            // resume the request queue and throw a non-abort error to signal a retry
+                            this.requestQueue.start();
+                            // TODO: We may want to have more detailed info such as team_id, params except tokens, and so on.
+                            throw new Error(`A rate limit was exceeded (url: ${url}, retry-after: ${retrySec})`);
+                        }
+                        else {
+                            // TODO: turn this into some CodedError
+                            throw new p_retry_1.AbortError(new Error(`Retry header did not contain a valid timeout (url: ${url}, retry-after header: ${response.headers['retry-after']})`));
                         }
-                        this.logger.info(`API Call failed due to rate limiting. Will retry in ${retrySec} seconds.`);
-                        // pause the request queue and then delay the rejection by the amount of time in the retry header
-                        this.requestQueue.pause();
-                        // NOTE: if there was a way to introspect the current RetryOperation and know what the next timeout
-                        // would be, then we could subtract that time from the following delay, knowing that it the next
-                        // attempt still wouldn't occur until after the rate-limit header has specified. an even better
-                        // solution would be to subtract the time from only the timeout of this next attempt of the
-                        // RetryOperation. this would result in the staying paused for the entire duration specified in the
-                        // header, yet this operation not having to pay the timeout cost in addition to that.
-                        await (0, helpers_1.default)(retrySec * 1000);
-                        // resume the request queue and throw a non-abort error to signal a retry
-                        this.requestQueue.start();
-                        // TODO: We may want to have more detailed info such as team_id, params except tokens, and so on.
-                        throw Error(`A rate limit was exceeded (url: ${url}, retry-after: ${retrySec})`);
                     }
-                    else {
-                        // TODO: turn this into some CodedError
-                        throw new p_retry_1.AbortError(new Error(`Retry header did not contain a valid timeout (url: ${url}, retry-after header: ${response.headers['retry-after']})`));
+                    // Slack's Web API doesn't use meaningful status codes besides 429 and 200
+                    if (response.status !== 200) {
+                        throw (0, errors_1.httpErrorFromResponse)(response);
                     }
+                    return response;
                 }
-                // Slack's Web API doesn't use meaningful status codes besides 429 and 200
-                if (response.status !== 200) {
-                    throw (0, errors_1.httpErrorFromResponse)(response);
-                }
-                return response;
-            }
-            catch (error) {
-                // To make this compatible with tsd, casting here instead of `catch (error: any)`
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                const e = error;
-                this.logger.warn('http request failed', e.message);
-                if (e.request) {
-                    throw (0, errors_1.requestErrorWithOriginal)(e);
+                catch (error) {
+                    // To make this compatible with tsd, casting here instead of `catch (error: any)`
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    const e = error;
+                    this.logger.warn('http request failed', e.message);
+                    if (e.request) {
+                        throw (0, errors_1.requestErrorWithOriginal)(e, this.attachOriginalToWebAPIRequestError);
+                    }
+                    throw error;
                 }
-                throw error;
-            }
+            }));
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            return (0, p_retry_1.default)(task, this.retryConfig);
         });
-        return (0, p_retry_1.default)(task, this.retryConfig);
     }
     /**
      * Transforms options (a simple key-value object) into an acceptable value for a body. This can be either
      * a string, used when posting with a content-type of url-encoded. Or, it can be a readable stream, used
      * when the options contain a binary (a stream or a buffer) and the upload should be done with content-type
      * multipart/form-data.
-     *
      * @param options - arguments for the Web API method
      * @param headers - a mutable object representing the HTTP headers for the outgoing request
      */
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     serializeApiCallOptions(options, headers) {
         // The following operation both flattens complex objects into a JSON-encoded strings and searches the values for
         // binary content
@@ -495,17 +531,20 @@ class WebClient extends methods_1.Methods {
                 }
                 return frm;
             }, new form_data_1.default());
-            // Copying FormData-generated headers into headers param
-            // not reassigning to headers param since it is passed by reference and behaves as an inout param
-            Object.entries(form.getHeaders()).forEach(([header, value]) => {
-                // eslint-disable-next-line no-param-reassign
-                headers[header] = value;
-            });
+            if (headers) {
+                // Copying FormData-generated headers into headers param
+                // not reassigning to headers param since it is passed by reference and behaves as an inout param
+                Object.entries(form.getHeaders()).forEach(([header, value]) => {
+                    // eslint-disable-next-line no-param-reassign
+                    headers[header] = value;
+                });
+            }
             return form;
         }
         // Otherwise, a simple key-value object is returned
         // eslint-disable-next-line no-param-reassign
-        headers['Content-Type'] = 'application/x-www-form-urlencoded';
+        if (headers)
+            headers['Content-Type'] = 'application/x-www-form-urlencoded';
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const initialValue = {};
         return (0, querystring_1.stringify)(flattened.reduce((accumulator, [key, value]) => {
@@ -521,69 +560,71 @@ class WebClient extends methods_1.Methods {
      * @param response - an http response
      */
     // eslint-disable-next-line class-methods-use-this
-    async buildResult(response) {
-        let { data } = response;
-        const isGzipResponse = response.headers['content-type'] === 'application/gzip';
-        // Check for GZIP response - if so, it is a successful response from admin.analytics.getFile
-        if (isGzipResponse) {
-            // admin.analytics.getFile will return a Buffer that can be unzipped
-            try {
-                const unzippedData = await new Promise((resolve, reject) => {
-                    zlib_1.default.unzip(data, (err, buf) => {
-                        if (err) {
-                            return reject(err);
-                        }
-                        return resolve(buf.toString().split('\n'));
-                    });
-                }).then((res) => res)
-                    .catch((err) => {
-                    throw err;
-                });
-                const fileData = [];
-                if (Array.isArray(unzippedData)) {
-                    unzippedData.forEach((dataset) => {
-                        if (dataset && dataset.length > 0) {
-                            fileData.push(JSON.parse(dataset));
-                        }
+    buildResult(response) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let { data } = response;
+            const isGzipResponse = response.headers['content-type'] === 'application/gzip';
+            // Check for GZIP response - if so, it is a successful response from admin.analytics.getFile
+            if (isGzipResponse) {
+                // admin.analytics.getFile will return a Buffer that can be unzipped
+                try {
+                    const unzippedData = yield new Promise((resolve, reject) => {
+                        zlib_1.default.unzip(data, (err, buf) => {
+                            if (err) {
+                                return reject(err);
+                            }
+                            return resolve(buf.toString().split('\n'));
+                        });
+                    }).then((res) => res)
+                        .catch((err) => {
+                        throw err;
                     });
+                    const fileData = [];
+                    if (Array.isArray(unzippedData)) {
+                        unzippedData.forEach((dataset) => {
+                            if (dataset && dataset.length > 0) {
+                                fileData.push(JSON.parse(dataset));
+                            }
+                        });
+                    }
+                    data = { file_data: fileData };
+                }
+                catch (err) {
+                    data = { ok: false, error: err };
                 }
-                data = { file_data: fileData };
             }
-            catch (err) {
-                data = { ok: false, error: err };
+            else if (!isGzipResponse && response.request.path === '/api/admin.analytics.getFile') {
+                // if it isn't a Gzip response but is from the admin.analytics.getFile request,
+                // decode the ArrayBuffer to JSON read the error
+                data = JSON.parse(new util_1.TextDecoder().decode(data));
             }
-        }
-        else if (!isGzipResponse && response.request.path === '/api/admin.analytics.getFile') {
-            // if it isn't a Gzip response but is from the admin.analytics.getFile request,
-            // decode the ArrayBuffer to JSON read the error
-            data = JSON.parse(new util_1.TextDecoder().decode(data));
-        }
-        if (typeof data === 'string') {
-            // response.data can be a string, not an object for some reason
-            try {
-                data = JSON.parse(data);
+            if (typeof data === 'string') {
+                // response.data can be a string, not an object for some reason
+                try {
+                    data = JSON.parse(data);
+                }
+                catch (_) {
+                    // failed to parse the string value as JSON data
+                    data = { ok: false, error: data };
+                }
             }
-            catch (_) {
-                // failed to parse the string value as JSON data
-                data = { ok: false, error: data };
+            if (data.response_metadata === undefined) {
+                data.response_metadata = {};
             }
-        }
-        if (data.response_metadata === undefined) {
-            data.response_metadata = {};
-        }
-        // add scopes metadata from headers
-        if (response.headers['x-oauth-scopes'] !== undefined) {
-            data.response_metadata.scopes = response.headers['x-oauth-scopes'].trim().split(/\s*,\s*/);
-        }
-        if (response.headers['x-accepted-oauth-scopes'] !== undefined) {
-            data.response_metadata.acceptedScopes = response.headers['x-accepted-oauth-scopes'].trim().split(/\s*,\s*/);
-        }
-        // add retry metadata from headers
-        const retrySec = parseRetryHeaders(response);
-        if (retrySec !== undefined) {
-            data.response_metadata.retryAfter = retrySec;
-        }
-        return data;
+            // add scopes metadata from headers
+            if (response.headers['x-oauth-scopes'] !== undefined) {
+                data.response_metadata.scopes = response.headers['x-oauth-scopes'].trim().split(/\s*,\s*/);
+            }
+            if (response.headers['x-accepted-oauth-scopes'] !== undefined) {
+                data.response_metadata.acceptedScopes = response.headers['x-accepted-oauth-scopes'].trim().split(/\s*,\s*/);
+            }
+            // add retry metadata from headers
+            const retrySec = parseRetryHeaders(response);
+            if (retrySec !== undefined) {
+                data.response_metadata.retryAfter = retrySec;
+            }
+            return data;
+        });
     }
 }
 exports.WebClient = WebClient;
@@ -628,20 +669,12 @@ function parseRetryHeaders(response) {
  * @param logger instance of web clients logger
  */
 function warnDeprecations(method, logger) {
-    const deprecatedConversationsMethods = ['channels.', 'groups.', 'im.', 'mpim.'];
-    const deprecatedMethods = ['admin.conversations.whitelist.', 'stars.'];
-    const isDeprecatedConversations = deprecatedConversationsMethods.some((depMethod) => {
-        const re = new RegExp(`^${depMethod}`);
-        return re.test(method);
-    });
+    const deprecatedMethods = ['workflows.'];
     const isDeprecated = deprecatedMethods.some((depMethod) => {
         const re = new RegExp(`^${depMethod}`);
         return re.test(method);
     });
-    if (isDeprecatedConversations) {
-        logger.warn(`${method} is deprecated. Please use the Conversations API instead. For more info, go to https://api.slack.com/changelog/2020-01-deprecating-antecedents-to-the-conversations-api`);
-    }
-    else if (isDeprecated) {
+    if (isDeprecated) {
         logger.warn(`${method} is deprecated. Please check on https://api.slack.com/methods for an alternative.`);
     }
 }
@@ -652,7 +685,7 @@ function warnDeprecations(method, logger) {
  * @param options arguments for the Web API method
  */
 function warnIfFallbackIsMissing(method, logger, options) {
-    const targetMethods = ['chat.postEphemeral', 'chat.postMessage', 'chat.scheduleMessage', 'chat.update'];
+    const targetMethods = ['chat.postEphemeral', 'chat.postMessage', 'chat.scheduleMessage'];
     const isTargetMethod = targetMethods.includes(method);
     const hasAttachments = (args) => Array.isArray(args.attachments) && args.attachments.length;
     const missingAttachmentFallbackDetected = (args) => Array.isArray(args.attachments) &&
@@ -699,7 +732,6 @@ exports.buildThreadTsWarningMessage = buildThreadTsWarningMessage;
  * @param body
  * @returns
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 function redact(body) {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const flattened = Object.entries(body).map(([key, value]) => {
@@ -721,8 +753,7 @@ function redact(body) {
         }
         return [key, serializedValue];
     });
-    // return as object 
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    // return as object
     const initialValue = {};
     return flattened.reduce((accumulator, [key, value]) => {
         if (key !== undefined && value !== undefined) {