cloudstructs 0.6.43 → 0.6.45

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

@@ -1,8 +1,11 @@
 "use strict";
-/// <reference lib="esnext.asynciterable" />
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -15,7 +18,7 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 var __importStar = (this && this.__importStar) || function (mod) {
     if (mod && mod.__esModule) return mod;
     var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
     __setModuleDefault(result, mod);
     return result;
 };
@@ -42,25 +45,36 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WebClientEvent = exports.WebClient = void 0;
-// polyfill for async iterable. see: https://stackoverflow.com/a/43694282/305340
-// can be removed once node v10 is the minimum target (node v8 and v9 require --harmony_async_iteration flag)
-if (Symbol['asyncIterator'] === undefined) {
-    (Symbol['asyncIterator']) = Symbol.for('asyncIterator');
-}
+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 util_1 = require("util");
 const is_stream_1 = __importDefault(require("is-stream"));
-const p_queue_1 = __importDefault(require("p-queue")); // tslint:disable-line:import-name
+const p_queue_1 = __importDefault(require("p-queue"));
 const p_retry_1 = __importStar(require("p-retry"));
 const axios_1 = __importDefault(require("axios"));
-const form_data_1 = __importDefault(require("form-data")); // tslint:disable-line:import-name
+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 errors_1 = require("./errors");
 const logger_1 = require("./logger");
-const retry_policies_1 = __importDefault(require("./retry-policies"));
-const helpers_1 = require("./helpers");
+const retry_policies_1 = require("./retry-policies");
+const helpers_1 = __importDefault(require("./helpers"));
+const file_upload_1 = require("./file-upload");
+/*
+ * Helpers
+ */
+const defaultFilename = 'Untitled';
+const defaultPageSize = 200;
+const noopPageReducer = () => undefined;
+var WebClientEvent;
+(function (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 = {}));
 /**
  * A client for Slack's Web API
  *
@@ -71,7 +85,7 @@ 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 = logger_1.LogLevel.INFO, maxRequestConcurrency = 3, retryConfig = retry_policies_1.default.tenRetriesInAboutThirtyMinutes, agent = undefined, tls = undefined, 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, } = {}) {
         super();
         this.token = token;
         this.slackApiUrl = slackApiUrl;
@@ -89,13 +103,15 @@ class WebClient extends methods_1.Methods {
             }
         }
         else {
-            this.logger = logger_1.getLogger(WebClient.loggerName, logLevel, logger);
+            this.logger = (0, logger_1.getLogger)(WebClient.loggerName, logLevel !== null && logLevel !== void 0 ? logLevel : logger_1.LogLevel.INFO, logger);
         }
+        // eslint-disable-next-line no-param-reassign
+        if (this.token && !headers.Authorization)
+            headers.Authorization = `Bearer ${this.token}`;
         this.axios = axios_1.default.create({
+            timeout,
             baseURL: slackApiUrl,
-            headers: Object.assign({
-                'User-Agent': instrument_1.getUserAgent(),
-            }, headers),
+            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)],
@@ -117,17 +133,23 @@ class WebClient extends methods_1.Methods {
      * @param method - the Web API method to call {@link https://api.slack.com/methods}
      * @param options - options
      */
-    async apiCall(method, 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}`);
         }
-        const response = await this.makeRequest(method, Object.assign({
-            token: this.token,
-            team_id: this.teamId,
-        }, options));
-        const result = this.buildResult(response);
+        (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));
@@ -152,9 +174,16 @@ class WebClient extends methods_1.Methods {
                 }
             });
         }
-        if (!result.ok) {
-            throw errors_1.platformErrorFromResult(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) {
@@ -163,7 +192,8 @@ class WebClient extends methods_1.Methods {
         }
         const pageSize = (() => {
             if (options !== undefined && typeof options.limit === 'number') {
-                const limit = options.limit;
+                const { limit } = options;
+                // eslint-disable-next-line no-param-reassign
                 delete options.limit;
                 return limit;
             }
@@ -172,7 +202,7 @@ class WebClient extends methods_1.Methods {
         function generatePages() {
             return __asyncGenerator(this, arguments, function* generatePages_1() {
                 // when result is undefined, that signals that the first of potentially many calls has not yet been made
-                let result = undefined;
+                let result;
                 // paginationOptions stores pagination options not already stored in the options argument
                 let paginationOptions = {
                     limit: pageSize,
@@ -182,6 +212,7 @@ class WebClient extends methods_1.Methods {
                 }
                 // NOTE: test for the situation where you're resuming a pagination using and existing cursor
                 while (result === undefined || paginationOptions !== undefined) {
+                    // eslint-disable-next-line no-await-in-loop
                     result = yield __await(this.apiCall(method, Object.assign(options !== undefined ? options : {}, paginationOptions)));
                     yield yield __await(result);
                     paginationOptions = paginationOptionsForNextPage(result, pageSize);
@@ -198,7 +229,7 @@ class WebClient extends methods_1.Methods {
             // 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 e_1, _a;
+            var _a, e_1, _b, _c;
             const pageIterator = generatePages.call(this);
             const firstIteratorResult = await pageIterator.next(undefined);
             // Assumption: there will always be at least one result in a paginated API request
@@ -211,43 +242,161 @@ class WebClient extends methods_1.Methods {
             }
             try {
                 // Continue iteration
-                for (var pageIterator_1 = __asyncValues(pageIterator), pageIterator_1_1; pageIterator_1_1 = await pageIterator_1.next(), !pageIterator_1_1.done;) {
-                    const page = pageIterator_1_1.value;
-                    accumulator = pageReducer(accumulator, page, index);
-                    if (shouldStop(page)) {
-                        return accumulator;
+                // 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;) {
+                    _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;
                     }
-                    index += 1;
                 }
             }
             catch (e_1_1) { e_1 = { error: e_1_1 }; }
             finally {
                 try {
-                    if (pageIterator_1_1 && !pageIterator_1_1.done && (_a = pageIterator_1.return)) await _a.call(pageIterator_1);
+                    if (!_d && !_a && (_b = pageIterator_1.return)) await _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:
+     *
+     * **#1**: For each file submitted with this method, submit filenames
+     * and file metadata to {@link https://api.slack.com/methods/files.getUploadURLExternal files.getUploadURLExternal} to request a URL to
+     * which to send the file data to and an id for the file
+     *
+     * **#2**: for each returned file `upload_url`, upload corresponding file to
+     * 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;
+        });
+        // 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
+     * and file metadata to files.getUploadURLExternal to request a URL to
+     * 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);
+        }));
+    }
+    /**
+     * 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)));
+    }
+    /**
+     * 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})`));
+                }
+                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}`));
+        }));
+    }
+    /**
+     * @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;
+    }
     /**
      * 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 () => {
-            this.logger.debug('will perform http request');
+            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 {
-                const response = await this.axios.post(url, body, Object.assign({
-                    headers,
-                }, this.tlsConfig));
+                // 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);
+                        this.emit(WebClientEvent.RATE_LIMITED, retrySec, { url, body });
                         if (this.rejectRateLimitedCalls) {
-                            throw new p_retry_1.AbortError(errors_1.rateLimitedErrorWithDelay(retrySec));
+                            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
@@ -258,31 +407,35 @@ class WebClient extends methods_1.Methods {
                         // 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 helpers_1.delay(retrySec * 1000);
+                        await (0, helpers_1.default)(retrySec * 1000);
                         // resume the request queue and throw a non-abort error to signal a retry
                         this.requestQueue.start();
-                        throw Error('A rate limit was exceeded.');
+                        // 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.'));
+                        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 errors_1.httpErrorFromResponse(response);
+                    throw (0, errors_1.httpErrorFromResponse)(response);
                 }
                 return response;
             }
             catch (error) {
-                this.logger.warn('http request failed', error.message);
-                if (error.request) {
-                    throw errors_1.requestErrorWithOriginal(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);
                 }
                 throw error;
             }
         });
-        return 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
@@ -293,17 +446,18 @@ class WebClient extends methods_1.Methods {
      * @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
         let containsBinaryData = false;
-        const flattened = Object.entries(options)
-            .map(([key, value]) => {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const flattened = Object.entries(options).map(([key, value]) => {
             if (value === undefined || value === null) {
                 return [];
             }
             let serializedValue = value;
-            if (Buffer.isBuffer(value) || is_stream_1.default(value)) {
+            if (Buffer.isBuffer(value) || (0, is_stream_1.default)(value)) {
                 containsBinaryData = true;
             }
             else if (typeof value !== 'string' && typeof value !== 'number' && typeof value !== 'boolean') {
@@ -315,43 +469,46 @@ class WebClient extends methods_1.Methods {
         });
         // A body with binary content should be serialized as multipart/form-data
         if (containsBinaryData) {
-            this.logger.debug('request arguments contain binary data');
-            const form = flattened.reduce((form, [key, value]) => {
-                if (Buffer.isBuffer(value) || is_stream_1.default(value)) {
-                    const options = {};
-                    options.filename = (() => {
+            this.logger.debug('Request arguments contain binary data');
+            const form = flattened.reduce((frm, [key, value]) => {
+                if (Buffer.isBuffer(value) || (0, is_stream_1.default)(value)) {
+                    const opts = {};
+                    opts.filename = (() => {
                         // attempt to find filename from `value`. adapted from:
-                        // tslint:disable-next-line:max-line-length
                         // https://github.com/form-data/form-data/blob/028c21e0f93c5fefa46a7bbf1ba753e4f627ab7a/lib/form_data.js#L227-L230
                         // formidable and the browser add a name property
                         // fs- and request- streams have path property
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
                         const streamOrBuffer = value;
                         if (typeof streamOrBuffer.name === 'string') {
-                            return path_1.basename(streamOrBuffer.name);
+                            return (0, path_1.basename)(streamOrBuffer.name);
                         }
                         if (typeof streamOrBuffer.path === 'string') {
-                            return path_1.basename(streamOrBuffer.path);
+                            return (0, path_1.basename)(streamOrBuffer.path);
                         }
                         return defaultFilename;
                     })();
-                    form.append(key, value, options);
+                    frm.append(key, value, opts);
                 }
                 else if (key !== undefined && value !== undefined) {
-                    form.append(key, value);
+                    frm.append(key, value);
                 }
-                return form;
+                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
-            for (const [header, value] of Object.entries(form.getHeaders())) {
+            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';
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const initialValue = {};
-        return querystring_1.stringify(flattened.reduce((accumulator, [key, value]) => {
+        return (0, querystring_1.stringify)(flattened.reduce((accumulator, [key, value]) => {
             if (key !== undefined && value !== undefined) {
                 accumulator[key] = value;
             }
@@ -359,12 +516,58 @@ class WebClient extends methods_1.Methods {
         }, initialValue));
     }
     /**
-     * Processes an HTTP response into a WebAPICallResult by performing JSON parsing on the body and merging relevent
+     * Processes an HTTP response into a WebAPICallResult by performing JSON parsing on the body and merging relevant
      * HTTP headers into the object.
      * @param response - an http response
      */
-    buildResult(response) {
-        const data = response.data;
+    // 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));
+                        }
+                    });
+                }
+                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));
+        }
+        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 };
+            }
+        }
         if (data.response_metadata === undefined) {
             data.response_metadata = {};
         }
@@ -373,8 +576,7 @@ class WebClient extends methods_1.Methods {
             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*/);
+            data.response_metadata.acceptedScopes = response.headers['x-accepted-oauth-scopes'].trim().split(/\s*,\s*/);
         }
         // add retry metadata from headers
         const retrySec = parseRetryHeaders(response);
@@ -390,16 +592,6 @@ exports.WebClient = WebClient;
  */
 WebClient.loggerName = 'WebClient';
 exports.default = WebClient;
-var WebClientEvent;
-(function (WebClientEvent) {
-    WebClientEvent["RATE_LIMITED"] = "rate_limited";
-})(WebClientEvent = exports.WebClientEvent || (exports.WebClientEvent = {}));
-/*
- * Helpers
- */
-const defaultFilename = 'Untitled';
-const defaultPageSize = 200;
-const noopPageReducer = () => undefined;
 /**
  * Determines an appropriate set of cursor pagination options for the next request to a paginated API method.
  * @param previousResult - the result of the last request, where the next cursor might be found.
@@ -415,7 +607,7 @@ function paginationOptionsForNextPage(previousResult, pageSize) {
             cursor: previousResult.response_metadata.next_cursor,
         };
     }
-    return;
+    return undefined;
 }
 /**
  * Extract the amount of time (in seconds) the platform has recommended this client wait before sending another request
@@ -437,7 +629,7 @@ function parseRetryHeaders(response) {
  */
 function warnDeprecations(method, logger) {
     const deprecatedConversationsMethods = ['channels.', 'groups.', 'im.', 'mpim.'];
-    const deprecatedMethods = ['admin.conversations.whitelist.'];
+    const deprecatedMethods = ['admin.conversations.whitelist.', 'stars.'];
     const isDeprecatedConversations = deprecatedConversationsMethods.some((depMethod) => {
         const re = new RegExp(`^${depMethod}`);
         return re.test(method);
@@ -453,4 +645,90 @@ function warnDeprecations(method, logger) {
         logger.warn(`${method} is deprecated. Please check on https://api.slack.com/methods for an alternative.`);
     }
 }
+/**
+ * Log a warning when using chat.postMessage without text argument or attachments with fallback argument
+ * @param method api method being called
+ * @param logger instance of we clients 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 isTargetMethod = targetMethods.includes(method);
+    const hasAttachments = (args) => Array.isArray(args.attachments) && args.attachments.length;
+    const missingAttachmentFallbackDetected = (args) => Array.isArray(args.attachments) &&
+        args.attachments.some((attachment) => !attachment.fallback || attachment.fallback.trim() === '');
+    const isEmptyText = (args) => args.text === undefined || args.text === null || args.text === '';
+    const buildMissingTextWarning = () => `The top-level \`text\` argument is missing in the request payload for a ${method} call - ` +
+        'It\'s a best practice to always provide a `text` argument when posting a message. ' +
+        'The `text` is used in places where the content cannot be rendered such as: ' +
+        'system push notifications, assistive technology such as screen readers, etc.';
+    const buildMissingFallbackWarning = () => `Additionally, the attachment-level \`fallback\` argument is missing in the request payload for a ${method} call - ` +
+        'To avoid this warning, it is recommended to always provide a top-level `text` argument when posting a message. ' +
+        'Alternatively, you can provide an attachment-level `fallback` argument, though this is now considered a legacy field (see https://api.slack.com/reference/messaging/attachments#legacy_fields for more details).';
+    if (isTargetMethod && typeof options === 'object') {
+        if (hasAttachments(options)) {
+            if (missingAttachmentFallbackDetected(options) && isEmptyText(options)) {
+                logger.warn(buildMissingTextWarning());
+                logger.warn(buildMissingFallbackWarning());
+            }
+        }
+        else if (isEmptyText(options)) {
+            logger.warn(buildMissingTextWarning());
+        }
+    }
+}
+/**
+ * Log a warning when thread_ts is not a string
+ * @param method api method being called
+ * @param logger instance of web clients logger
+ * @param options arguments for the Web API method
+ */
+function warnIfThreadTsIsNotString(method, logger, options) {
+    const targetMethods = ['chat.postEphemeral', 'chat.postMessage', 'chat.scheduleMessage', 'files.upload'];
+    const isTargetMethod = targetMethods.includes(method);
+    if (isTargetMethod && (options === null || options === void 0 ? void 0 : options.thread_ts) !== undefined && typeof (options === null || options === void 0 ? void 0 : options.thread_ts) !== 'string') {
+        logger.warn(buildThreadTsWarningMessage(method));
+    }
+}
+function buildThreadTsWarningMessage(method) {
+    return `The given thread_ts value in the request payload for a ${method} call is a float value. We highly recommend using a string value instead.`;
+}
+exports.buildThreadTsWarningMessage = buildThreadTsWarningMessage;
+/**
+ * Takes an object and redacts specific items
+ * @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]) => {
+        // no value provided
+        if (value === undefined || value === null) {
+            return [];
+        }
+        let serializedValue = value;
+        // redact possible tokens
+        if (key.match(/.*token.*/) !== null || key.match(/[Aa]uthorization/)) {
+            serializedValue = '[[REDACTED]]';
+        }
+        // when value is buffer or stream we can avoid logging it
+        if (Buffer.isBuffer(value) || (0, is_stream_1.default)(value)) {
+            serializedValue = '[[BINARY VALUE OMITTED]]';
+        }
+        else if (typeof value !== 'string' && typeof value !== 'number' && typeof value !== 'boolean') {
+            serializedValue = JSON.stringify(value);
+        }
+        return [key, serializedValue];
+    });
+    // return as object 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const initialValue = {};
+    return flattened.reduce((accumulator, [key, value]) => {
+        if (key !== undefined && value !== undefined) {
+            accumulator[key] = value;
+        }
+        return accumulator;
+    }, initialValue);
+}
 //# sourceMappingURL=WebClient.js.map