@nu-art/slack-backend 0.401.8 → 0.500.0

package/ModuleBE_Slack.d.ts

@@ -3,7 +3,7 @@
  */
 import { Module } from '@nu-art/ts-common';
 import { WebClientOptions } from '@slack/web-api';
-import { PreSendSlackStructuredMessage } from '@nu-art/slack-shared';
+import { API_Slack, PreSendSlackStructuredMessage } from '@nu-art/slack-shared';
 import { Stream } from 'stream';
 export type ConfigType_ModuleBE_Slack = {
     token: string;
@@ -28,9 +28,13 @@ export declare class ModuleBE_Slack_Class extends Module<ConfigType_ModuleBE_Sla
     private messageMap;
     constructor();
     protected init(): void;
-    postMessage(text: string, channel?: string, thread?: ThreadPointer): Promise<ThreadPointer | undefined>;
+    postMessage(request: API_Slack['postMessage']['Body']): Promise<void>;
+    postStructuredMessage(request: API_Slack['postStructuredMessage']['Body']): Promise<API_Slack['postStructuredMessage']['Response']>;
+    sendFEMessage(request: API_Slack['sendFEMessage']['Body']): Promise<void>;
+    postFiles(request: API_Slack['postFiles']['Body']): Promise<API_Slack['postFiles']['Response']>;
+    sendText(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>;
+    sendStructured(message: PreSendSlackStructuredMessage, thread?: ThreadPointer): Promise<ThreadPointer>;
     private postMessageImpl;
     uploadFile: (file: Buffer | Stream, name: string, tp?: ThreadPointer) => Promise<import("@slack/web-api").FilesUploadResponse>;
     getUserIdByEmail(email: string): Promise<string | undefined>;

package/ModuleBE_Slack.js

@@ -16,134 +16,188 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
 /**
  * Created by AlanBen on 29/08/2019.
  */
 import { currentTimeMillis, 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 { ApiHandler } from '@nu-art/http-server';
 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 = {
-            channel: channel ?? this.config.defaultChannel,
-        };
-        // @ts-ignore - no clue why, their api requires text but it is not in the te
-        message.text = text;
-        //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();
+let ModuleBE_Slack_Class = (() => {
+    let _classSuper = Module;
+    let _instanceExtraInitializers = [];
+    let _postMessage_decorators;
+    let _postStructuredMessage_decorators;
+    let _sendFEMessage_decorators;
+    let _postFiles_decorators;
+    return class ModuleBE_Slack_Class extends _classSuper {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _postMessage_decorators = [ApiHandler(ApiDef_Slack.postMessage)];
+            _postStructuredMessage_decorators = [ApiHandler(ApiDef_Slack.postStructuredMessage)];
+            _sendFEMessage_decorators = [ApiHandler(ApiDef_Slack.sendFEMessage)];
+            _postFiles_decorators = [ApiHandler(ApiDef_Slack.postFiles)];
+            __esDecorate(this, null, _postMessage_decorators, { kind: "method", name: "postMessage", static: false, private: false, access: { has: obj => "postMessage" in obj, get: obj => obj.postMessage }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _postStructuredMessage_decorators, { kind: "method", name: "postStructuredMessage", static: false, private: false, access: { has: obj => "postStructuredMessage" in obj, get: obj => obj.postStructuredMessage }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _sendFEMessage_decorators, { kind: "method", name: "sendFEMessage", static: false, private: false, access: { has: obj => "sendFEMessage" in obj, get: obj => obj.sendFEMessage }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _postFiles_decorators, { kind: "method", name: "postFiles", static: false, private: false, access: { has: obj => "postFiles" in obj, get: obj => obj.postFiles }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
         }
-        catch (e) {
-            throw HttpCodes._5XX.INTERNAL_SERVER_ERROR(`Failed at uploading file to url: ${e.message}`);
+        web = __runInitializers(this, _instanceExtraInitializers);
+        messageMap = {};
+        constructor() {
+            super('slack');
+            this.setDefaultConfig({ unfurl_links: false, unfurl_media: false });
         }
-        // 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;
-        return await this.postMessageImpl(message, thread);
-    }
-    async postMessageImpl(message, threadPointer) {
-        try {
-            if (threadPointer) {
-                message.thread_ts = threadPointer.ts;
-                message.channel = threadPointer.channel;
+        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
+            });
+        }
+        async postMessage(request) {
+            await this.sendText(request.message, request.channel);
+        }
+        async postStructuredMessage(request) {
+            return { threadPointer: await this.sendStructured(request.message, request.thread) };
+        }
+        async sendFEMessage(request) {
+            const slackMessage = new SlackBuilderBE(request.channel, request.messageBlocks, request.messageReplies);
+            await slackMessage.send();
+        }
+        async postFiles(request) {
+            return this.postFile(request.file, request.name, request.thread);
+        }
+        async sendText(text, channel, thread) {
+            const message = {
+                channel: channel ?? this.config.defaultChannel,
+            };
+            // @ts-ignore - no clue why, their api requires text but it is not in the te
+            message.text = text;
+            //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 {
+                const res = await fetch(upload_url, {
+                    method: 'POST',
+                    body: file,
+                });
+                if (!res.ok)
+                    throw new Error(`Upload failed: ${res.status} ${res.statusText}`);
             }
-            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);
-            return { ts: res.ts, channel: res.channel };
+            catch (e) {
+                const message = e instanceof Error ? e.message : String(e);
+                throw HttpCodes._5XX.INTERNAL_SERVER_ERROR(`Failed at uploading file to url: ${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;
         }
-        catch (err) {
-            throw HttpCodes._5XX.INTERNAL_SERVER_ERROR(postSlackMessageErrorHandler(err, message.channel));
+        async sendStructured(message, thread) {
+            message.channel ??= this.config.defaultChannel;
+            return await this.postMessageImpl(message, thread);
         }
-    }
-    uploadFile = async (file, name, tp) => {
-        const channel = tp?.channel || this.config.defaultChannel;
-        const fileUploadBlob = {
-            channels: channel,
-            file: file,
-            filename: name,
+        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);
+                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);
         };
-        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;
+        async getUserIdByEmail(email) {
+            const result = await this.web.users.lookupByEmail({ email });
+            if (result.ok)
+                // @ts-ignore
+                return result.user.id;
+            return undefined;
         }
-    }
-    getDefaultChannel = () => {
-        return this.config.defaultChannel;
+        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 { ModuleBE_Slack_Class };
 export const ModuleBE_Slack = new ModuleBE_Slack_Class();

package/SlackBuilderBE.js

@@ -2,11 +2,9 @@ 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')
@@ -31,7 +29,7 @@ export class SlackBuilderBE extends BaseSlackBuilder {
     };
     sendMessage = async () => {
         this.convertLongSectionBlocks();
-        return ModuleBE_Slack.postStructuredMessage({
+        return ModuleBE_Slack.sendStructured({
             channel: this.channel,
             blocks: this.blocks
         });
@@ -45,7 +43,7 @@ export class SlackBuilderBE extends BaseSlackBuilder {
     };
     sendReplies = async (tp) => {
         for (const reply of this.replies) {
-            await ModuleBE_Slack.postStructuredMessage({
+            await ModuleBE_Slack.sendStructured({
                 blocks: reply
             }, tp);
         }

package/Slack_ServerApiError.js

@@ -74,7 +74,7 @@ export class Slack_ServerApiError_Class extends Module {
             if (message.includes(key))
                 return;
         }
-        return ModuleBE_Slack.postMessage(message, undefined, threadPointer);
+        return ModuleBE_Slack.sendText(message, undefined, threadPointer);
     }
 }
 export const Slack_ServerApiError = new Slack_ServerApiError_Class();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nu-art/slack-backend",
-  "version": "0.401.8",
+  "version": "0.500.0",
   "description": "Storm - Express & Typescript based backend framework Backend",
   "keywords": [
     "TacB0sS",
@@ -31,10 +31,8 @@
     "build": "tsc"
   },
   "dependencies": {
-    "@nu-art/slack-shared": "0.401.8",
-    "@nu-art/thunderstorm-backend": "0.401.8",
-    "@nu-art/thunderstorm-shared": "0.401.8",
-    "@nu-art/ts-common": "0.401.8",
+    "@nu-art/slack-shared": "0.500.0",
+    "@nu-art/ts-common": "0.500.0",
     "@slack/web-api": "7.13.0",
     "firebase": "^11.9.0",
     "firebase-admin": "13.4.0",
@@ -43,7 +41,9 @@
     "moment": "^2.29.4",
     "react": "^18.0.0",
     "react-dom": "^18.0.0",
-    "react-router-dom": "^6.9.0"
+    "react-router-dom": "^6.9.0",
+    "@nu-art/http-server": "{{THUNDERSTORM_VERSION}}",
+    "@nu-art/api-types": "{{THUNDERSTORM_VERSION}}"
   },
   "devDependencies": {
     "@types/react": "^18.0.0",