@nu-art/slack-backend 0.400.5

package/ModuleBE_Slack.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Created by AlanBen on 29/08/2019.
+ */
+import { Module } from '@nu-art/ts-common';
+import { WebClientOptions } from '@slack/web-api';
+import { PreSendSlackStructuredMessage } from '@nu-art/slack-shared';
+import { Stream } from 'stream';
+export type ConfigType_ModuleBE_Slack = {
+    token: string;
+    defaultChannel: string;
+    throttlingTime?: number;
+    slackConfig?: Partial<WebClientOptions>;
+    unfurl_links?: boolean;
+    unfurl_media?: boolean;
+};
+type _SlackMessage = {
+    text: string;
+    channel?: string;
+    messageId?: string;
+};
+export type SlackMessage = string | _SlackMessage;
+export type ThreadPointer = {
+    ts?: string;
+    channel: string;
+};
+export declare class ModuleBE_Slack_Class extends Module<ConfigType_ModuleBE_Slack, any> {
+    private web;
+    private messageMap;
+    constructor();
+    protected init(): void;
+    postMessage(text: string, channel?: string, thread?: ThreadPointer): Promise<ThreadPointer | undefined>;
+    postFile(file: Buffer, name: string, thread?: ThreadPointer): Promise<import("@slack/web-api").FilesCompleteUploadExternalResponse>;
+    postStructuredMessage(message: PreSendSlackStructuredMessage, thread?: ThreadPointer): Promise<ThreadPointer | undefined>;
+    private postMessageImpl;
+    uploadFile: (file: Buffer | Stream, name: string, tp?: ThreadPointer) => Promise<import("@slack/web-api").FilesUploadResponse>;
+    getUserIdByEmail(email: string): Promise<string | undefined>;
+    openDM(userIds: string[]): Promise<string | undefined>;
+    getDefaultChannel: () => any;
+}
+export declare const ModuleBE_Slack: ModuleBE_Slack_Class;
+export {};

package/ModuleBE_Slack.js

@@ -0,0 +1,155 @@
+/*
+ * Storm contains a list of utility functions.. this project
+ * might be broken down into more smaller projects in the future.
+ *
+ * Copyright (C) 2020 Adam van der Kruk aka TacB0sS
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Created by AlanBen on 29/08/2019.
+ */
+import { currentTimeMillis, generateHex, ImplementationMissingException, md5, Minute, Module } from '@nu-art/ts-common';
+import { WebClient, } from '@slack/web-api';
+import { addRoutes, AxiosHttpModule, createBodyServerApi } from '@nu-art/thunderstorm-backend';
+import { ApiDef_Slack } from '@nu-art/slack-shared';
+import { postSlackMessageErrorHandler } from './utils.js';
+import { HttpCodes } from '@nu-art/ts-common/core/exceptions/http-codes';
+import { SlackBuilderBE } from './SlackBuilderBE.js';
+import { HttpMethod } from '@nu-art/thunderstorm-shared';
+export class ModuleBE_Slack_Class extends Module {
+    web;
+    messageMap = {};
+    constructor() {
+        super('slack');
+        this.setDefaultConfig({ unfurl_links: false, unfurl_media: false });
+    }
+    init() {
+        if (!this.config.token)
+            throw new ImplementationMissingException('Missing config token for ModuleBE_Slack. Please add it');
+        this.web = new WebClient(this.config.token, {
+            rejectRateLimitedCalls: true,
+            ...this.config.slackConfig
+        });
+        addRoutes([
+            createBodyServerApi(ApiDef_Slack.vv1.postMessage, async (request) => {
+                await this.postMessage(request.message, request.channel);
+            }),
+            createBodyServerApi(ApiDef_Slack.vv1.postStructuredMessage, async (request) => {
+                return { threadPointer: await this.postStructuredMessage(request.message, request.thread) };
+            }),
+            createBodyServerApi(ApiDef_Slack.vv1.sendFEMessage, async (request) => {
+                const slackMessage = new SlackBuilderBE(request.channel, request.messageBlocks, request.messageReplies);
+                await slackMessage.send();
+            }),
+            createBodyServerApi(ApiDef_Slack.vv1.postFiles, async (request) => this.postFile(request.file, request.name, request.thread))
+        ]);
+    }
+    async postMessage(text, channel, thread) {
+        const message = {
+            text,
+            channel: channel ?? this.config.defaultChannel,
+        };
+        //Block same message on throttling time
+        const time = this.messageMap[md5(text)];
+        if (time && currentTimeMillis() - time < (this.config.throttlingTime || Minute))
+            return;
+        //Post and return thread
+        return await this.postMessageImpl(message, thread);
+    }
+    async postFile(file, name, thread) {
+        // Get a URL to upload
+        const uploadUrlResponse = await this.web.files.getUploadURLExternal({
+            filename: name,
+            length: file.length
+        });
+        if (!uploadUrlResponse.ok)
+            throw HttpCodes._5XX.INTERNAL_SERVER_ERROR(`Failed at getting a URL from slack: ${uploadUrlResponse.error}`);
+        const { upload_url, file_id } = uploadUrlResponse;
+        try {
+            await AxiosHttpModule.createRequest({
+                fullUrl: upload_url,
+                path: '',
+                method: HttpMethod.POST
+            })
+                .setBody(file)
+                .executeSync();
+        }
+        catch (e) {
+            throw HttpCodes._5XX.INTERNAL_SERVER_ERROR(`Failed at uploading file to url: ${e.message}`);
+        }
+        // Complete the upload - post the file to slack message
+        const completeResponse = await this.web.files.completeUploadExternal({
+            files: [{ id: file_id }],
+            channel_id: thread ? thread.channel : this.config.defaultChannel,
+            thread_ts: thread?.ts,
+        });
+        if (!completeResponse.ok)
+            throw HttpCodes._5XX.INTERNAL_SERVER_ERROR(`Failed at complete uploading: ${completeResponse.error}`);
+        return completeResponse;
+    }
+    async postStructuredMessage(message, thread) {
+        message.channel ??= this.config.defaultChannel;
+        message.text ??= generateHex(8);
+        const time = this.messageMap[message.text];
+        if (time && currentTimeMillis() - time < (this.config.throttlingTime || Minute))
+            return;
+        return await this.postMessageImpl(message, thread);
+    }
+    async postMessageImpl(message, threadPointer) {
+        try {
+            if (threadPointer) {
+                message.thread_ts = threadPointer.ts;
+                message.channel = threadPointer.channel;
+            }
+            message.unfurl_links = this.config.unfurl_links;
+            message.unfurl_media = this.config.unfurl_media;
+            this.logDebug(`Sending message in ${threadPointer ? 'thread' : 'channel'}`, message);
+            const res = await this.web.chat.postMessage(message);
+            //Add message to map
+            this.messageMap[md5(message.text)] = currentTimeMillis();
+            this.logDebug(`A message was posted to channel: ${message.channel} with message id ${res.ts} which contains the message ${message.text}`);
+            return { ts: res.ts, channel: res.channel };
+        }
+        catch (err) {
+            throw HttpCodes._5XX.INTERNAL_SERVER_ERROR(postSlackMessageErrorHandler(err, message.channel));
+        }
+    }
+    uploadFile = async (file, name, tp) => {
+        const channel = tp?.channel || this.config.defaultChannel;
+        const fileUploadBlob = {
+            channels: channel,
+            file: file,
+            filename: name,
+        };
+        return await this.web.files.upload(fileUploadBlob);
+    };
+    async getUserIdByEmail(email) {
+        const result = await this.web.users.lookupByEmail({ email });
+        if (result.ok)
+            // @ts-ignore
+            return result.user.id;
+        return undefined;
+    }
+    async openDM(userIds) {
+        const users = userIds.join(',');
+        const result = await this.web.conversations.open({ users });
+        if (result.ok) { // @ts-ignore
+            return result.channel.id;
+        }
+    }
+    getDefaultChannel = () => {
+        return this.config.defaultChannel;
+    };
+}
+export const ModuleBE_Slack = new ModuleBE_Slack_Class();

package/SlackBuilderBE.d.ts

@@ -0,0 +1,9 @@
+import { ThreadPointer } from './ModuleBE_Slack.js';
+import { BaseSlackBuilder, SlackBlock } from '@nu-art/slack-shared';
+export declare class SlackBuilderBE extends BaseSlackBuilder {
+    constructor(channel?: string, blocks?: SlackBlock[], replies?: SlackBlock[][]);
+    private convertLongSectionBlocks;
+    protected sendMessage: () => Promise<ThreadPointer | undefined>;
+    protected sendFiles: (tp: ThreadPointer) => Promise<void>;
+    protected sendReplies: (tp: ThreadPointer) => Promise<void>;
+}

package/SlackBuilderBE.js

@@ -0,0 +1,53 @@
+import { ModuleBE_Slack } from './ModuleBE_Slack.js';
+import { BaseSlackBuilder } from '@nu-art/slack-shared';
+import { __stringify, currentTimeMillis, formatTimestamp, generateHex } from '@nu-art/ts-common';
+export class SlackBuilderBE extends BaseSlackBuilder {
+    // ######################## Builder Steps ########################
+    constructor(channel, blocks, replies) {
+        super(channel, blocks, replies);
+    }
+    // ######################## Internal Logic ########################
+    convertLongSectionBlocks = () => {
+        const convertBlock = (block) => {
+            if (block.type !== 'section')
+                return;
+            //@ts-ignore - text does exist on the block at this point
+            const text = block.text.text;
+            if (text.length < 3000)
+                return;
+            //Convert the text into a file
+            const fileName = `${formatTimestamp('DD/MM/YYYY_HH:mm', currentTimeMillis())}_${generateHex(8)}`;
+            const buffer = Buffer.from(__stringify(text, true), 'utf-8');
+            this.addFiles({
+                title: fileName,
+                fileName: fileName,
+                file: buffer
+            });
+            // @ts-ignore
+            block.text.text = `Message was too long, converted to file "${fileName}"`;
+        };
+        this.blocks.forEach(convertBlock);
+        this.replies.forEach(reply => reply.forEach(convertBlock));
+    };
+    sendMessage = async () => {
+        this.convertLongSectionBlocks();
+        return ModuleBE_Slack.postStructuredMessage({
+            channel: this.channel,
+            blocks: this.blocks
+        });
+    };
+    sendFiles = async (tp) => {
+        await Promise.all(this.files.map(async (file) => {
+            const response = await ModuleBE_Slack.postFile(file.file, file.fileName, tp);
+            if (!response.ok)
+                return this.logError(response?.error);
+        }));
+    };
+    sendReplies = async (tp) => {
+        for (const reply of this.replies) {
+            await ModuleBE_Slack.postStructuredMessage({
+                blocks: reply
+            }, tp);
+        }
+    };
+}

package/Slack_ServerApiError.d.ts

@@ -0,0 +1,14 @@
+import { CustomException, ErrorMessage, Module, ServerErrorSeverity } from '@nu-art/ts-common';
+type Config = {
+    exclude: string[];
+    minLevel: ServerErrorSeverity;
+};
+export declare class Slack_ServerApiError_Class extends Module<Config> {
+    constructor();
+    protected init(): void;
+    __processApplicationError(errorLevel: ServerErrorSeverity, module: Module, message: ErrorMessage): Promise<void>;
+    __processExceptionError(errorLevel: ServerErrorSeverity, exception: CustomException): Promise<void>;
+    private sendMessage;
+}
+export declare const Slack_ServerApiError: Slack_ServerApiError_Class;
+export {};

package/Slack_ServerApiError.js

@@ -0,0 +1,80 @@
+/*
+ * Storm contains a list of utility functions.. this project
+ * might be broken down into more smaller projects in the future.
+ *
+ * Copyright (C) 2020 Adam van der Kruk aka TacB0sS
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Module, ServerErrorSeverity, ServerErrorSeverity_Ordinal } from '@nu-art/ts-common';
+import { ModuleBE_Slack } from './ModuleBE_Slack.js';
+export class Slack_ServerApiError_Class extends Module {
+    constructor() {
+        super();
+        this.setDefaultConfig({ exclude: [], minLevel: ServerErrorSeverity.Info });
+    }
+    init() {
+    }
+    async __processApplicationError(errorLevel, module, message) {
+        if (ServerErrorSeverity_Ordinal.indexOf(errorLevel) < ServerErrorSeverity_Ordinal.indexOf(this.config.minLevel))
+            return;
+        const threadPointer = await this.sendMessage(message.message);
+        if (!threadPointer)
+            return;
+        for (const innerMessage of (message.innerMessages || [])) {
+            await this.sendMessage(innerMessage, threadPointer);
+        }
+    }
+    // public composeSlackStructuredMessage = (exception: CustomException, channel?: string): ChatPostMessageArguments => {
+    // 	let dataMessage = `No message composer defined for type ${exception.exceptionType}`;
+    //
+    // 	if (exception.isInstanceOf(ApiException))
+    // 		dataMessage = Composer_ApiException(exception as ApiException);
+    // 	else if (exception.isInstanceOf(BadImplementationException))
+    // 		dataMessage = Composer_BadImplementationException(exception);
+    // 	else if (exception.isInstanceOf(ThisShouldNotHappenException))
+    // 		dataMessage = Composer_ThisShouldNotHappenException(exception);
+    //
+    // 	return {
+    // 		text: Composer_NotificationText(exception),
+    // 		channel: channel!,
+    // 		blocks: SlackBuilder_TextSectionWithTitle(':octagonal_sign:  *API Error*', dataMessage)
+    // 	};
+    // };
+    async __processExceptionError(errorLevel, exception) {
+        if (ServerErrorSeverity_Ordinal.indexOf(errorLevel) < ServerErrorSeverity_Ordinal.indexOf(this.config.minLevel))
+            return;
+        // const message = this.composeSlackStructuredMessage(exception);
+        // const thread = await ModuleBE_Slack.postStructuredMessage(message);
+        // if (!thread)
+        // 	return;
+        //Send a full stack reply in thread
+        // const stackSection: ChatPostMessageArguments = {
+        // 	blocks: [
+        // 		SlackBuilder_TextSection(''),
+        // 		SlackBuilder_Divider(),
+        // 		SlackBuilder_TextSection(`\`\`\`${exception.stack}\`\`\``),
+        // 	]
+        // } as ChatPostMessageArguments;
+        // if (stackSection)
+        // await ModuleBE_Slack.postStructuredMessage(stackSection, thread);
+    }
+    sendMessage(message, threadPointer) {
+        for (const key of this.config.exclude || []) {
+            if (message.includes(key))
+                return;
+        }
+        return ModuleBE_Slack.postMessage(message, undefined, threadPointer);
+    }
+}
+export const Slack_ServerApiError = new Slack_ServerApiError_Class();

package/index.d.ts

@@ -0,0 +1,3 @@
+export * from './ModuleBE_Slack.js';
+export * from './Slack_ServerApiError.js';
+export * from './SlackBuilderBE.js';

package/index.js

@@ -0,0 +1,21 @@
+/*
+ * Storm contains a list of utility functions.. this project
+ * might be broken down into more smaller projects in the future.
+ *
+ * Copyright (C) 2020 Adam van der Kruk aka TacB0sS
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export * from './ModuleBE_Slack.js';
+export * from './Slack_ServerApiError.js';
+export * from './SlackBuilderBE.js';

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "@nu-art/slack-backend",
+  "version": "0.400.5",
+  "description": "Storm - Express & Typescript based backend framework Backend",
+  "keywords": [
+    "TacB0sS",
+    "infra",
+    "nu-art",
+    "storm",
+    "thunderstorm",
+    "typescript"
+  ],
+  "homepage": "https://github.com/nu-art-js/storm",
+  "bugs": {
+    "url": "https://github.com/nu-art-js/storm/issues"
+  },
+  "publishConfig": {
+    "directory": "dist",
+    "linkDirectory": true
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com:nu-art-js/storm.git"
+  },
+  "license": "Apache-2.0",
+  "author": "TacB0sS",
+  "files": [
+    "**/*"
+  ],
+  "scripts": {
+    "build": "tsc"
+  },
+  "dependencies": {
+    "@nu-art/slack-shared": "0.400.5",
+    "@nu-art/thunderstorm-backend": "0.400.5",
+    "@nu-art/thunderstorm-shared": "0.400.5",
+    "@nu-art/ts-common": "0.400.5",
+    "@slack/events-api": "^2.3.0",
+    "@slack/web-api": "7.9.3",
+    "firebase": "^11.9.0",
+    "firebase-admin": "13.4.0",
+    "firebase-functions": "6.3.2",
+    "google-auth-library": "^10.0.0",
+    "moment": "^2.29.4",
+    "react": "^18.0.0",
+    "react-dom": "^18.0.0",
+    "react-router-dom": "^6.9.0",
+    "request": "^2.88.0"
+  },
+  "devDependencies": {
+    "@types/react": "^18.0.0",
+    "@types/react-dom": "^18.0.0",
+    "@types/react-router": "^5.1.20",
+    "@types/react-router-dom": "^5.3.3"
+  },
+  "unitConfig": {
+    "type": "typescript-lib"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./index.js"
+    },
+    "./*": {
+      "types": "./*.d.ts",
+      "import": "./*.js"
+    }
+  }
+}

package/utils.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Receives slack error and returns a human-readable error message
+ * @param error The error received from the api call
+ */
+export declare const postSlackMessageErrorHandler: (error: any, channel?: string) => string;

package/utils.js

@@ -0,0 +1,44 @@
+/**
+ * Receives slack error and returns a human-readable error message
+ * @param error The error received from the api call
+ */
+export const postSlackMessageErrorHandler = (error, channel) => {
+    const prefix = 'Slack error! ';
+    if (error.data && error.data.error) {
+        switch (error.data.error) {
+            case 'channel_not_found':
+                return `${prefix}The specified channel (Channel '${channel}') does not exist or is not accessible by your access token. Please double check defined channel in config and adjust if needed`;
+            case 'not_in_channel':
+                return `${prefix}The bot or user is not a member of the specified channel. (Channel '${channel}')`;
+            case 'is_archived':
+                return `${prefix}The channel has been archived and cannot be written to. (Channel '${channel}')`;
+            case 'msg_too_long':
+                return `${prefix}The message text exceeds the maximum allowed length.`;
+            case 'no_text':
+                return `${prefix}The message text was provided empty.`;
+            case 'rate_limited':
+                return `${prefix}Too many messages have been sent in a short period. Please try again later.`;
+            case 'not_authed':
+                return `${prefix}No authentication token was provided. Please provide a valid token.`;
+            case 'invalid_auth':
+                return `${prefix}The authentication token provided is invalid. Please check your token settings.`;
+            case 'access_denied':
+                return `${prefix}Access has been denied. The token does not have the necessary permissions to perform this operation.`;
+            case 'account_inactive':
+                return `${prefix}The user account associated with the token is inactive.`;
+            case 'token_revoked':
+                return `${prefix}The token has been revoked.`;
+            case 'no_permission':
+                return `${prefix}The token does not have the necessary permission to post messages in the specified channel. (Channel '${channel}')`;
+            case 'user_is_bot':
+                return `${prefix}The user associated with the token is a bot, which cannot post messages.`;
+            case 'team_access_not_granted':
+                return `${prefix}The application has not been granted access to post messages in the specified team. (Channel '${channel}')`;
+            default:
+                return `${prefix}An unexpected error occurred: ${error.data.error}`;
+        }
+    }
+    else {
+        return `${prefix}An unknown error occurred. Please check your network and try again.`;
+    }
+};