Quick-fix

.gitea/workflows/publish.yml

@@ -0,0 +1,30 @@
+name: Publish to NPM
+
+on:
+  workflow_dispatch:
+  release:
+    types: [published]
+
+jobs:
+    build-and-publish:
+        runs-on: ubuntu-latest
+        steps:
+            - name: Checkout code
+              uses: actions/checkout@v4
+            
+            - name: Setup Node.js
+              uses: actions/setup-node@v4
+              with:
+                node-version: "24"
+
+            - name: Install dependencies
+              run: npm ci
+
+            - name: Build TypeScript
+              run: npm run build
+            
+            - name: Add NPM token
+              run: echo "//registry.npmjs.org/:_authToken=${{ secrets.NPM_TOKEN }}" > .npmrc
+
+            - name: Publish to NPM
+              run: npm publish --access public

.gitignore

@@ -13,4 +13,5 @@ yarn-error.log*
 .DS_Store
 .env
 .env.*
-!.env.example
+!.env.example
+/dist

README.md

@@ -0,0 +1,6 @@
+# Chatenium SDK For TypeScript
+A library for interacting with the Chatenium API.
+## Quick Start
+```aiignore
+npm install @chatenium/chatenium-sdk
+```

package.json

@@ -1,8 +1,28 @@
 {
-  "name": "chatenium-sdk",
-  "version": "1.0.0",
-  "description": "",
+  "name": "@chatenium/chatenium-sdk",
+  "version": "1.0.3",
+  "description": "A library for interacting with the Chatenium API",
+  "type": "module",
   "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./core/*": "./dist/core/*.js",
+    "./services/*": "./dist/services/*.js",
+    "./domain/*": "./dist/domain/*.js",
+    "./mocks/*": "./dist/mocks/*.js",
+    "./storage/*": "./dist/storage/*.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
   "scripts": {
     "build": "tsc",
     "test": "vitest run",
@@ -15,7 +35,7 @@
     "typescript": "^5.5.3",
     "vitest": "^4.1.2"
   },
-  "private": true,
+  "private": false,
   "dependencies": {
     "@faker-js/faker": "^10.4.0",
     "axios": "^1.14.0",

src/core/environment.ts

@@ -4,6 +4,9 @@ export interface SDKConfig {
     wsUrl: string;
 }
 
+declare const process: any;
+declare const require: any;
+
 const isNode =
     typeof process !== 'undefined' &&
     typeof process.versions !== 'undefined' &&

src/domain/broadcastChannelService.schema.ts

@@ -0,0 +1,28 @@
+export interface CreateServerReq {
+    type: "rtmp",
+    channelId: string
+    categoryId: string
+    networkId: string
+}
+
+export interface GetRTMPDataReq {
+    channelId: string
+    networkId: string
+    categoryId: string
+}
+
+export interface JoinWebsocketRoomReq {
+    userid: string
+    connId: string
+    channelId: string
+    networkId: string
+    categoryId: string
+}
+
+export interface StreamRegistry {
+    streamKey: string
+    status: "idling" | "broadcasting" | "broadcasting_starting"
+    type: "rtmp"
+    streamURL: string
+    channelId: string
+}

src/domain/fileTransferService.schema.ts

@@ -0,0 +1,95 @@
+export interface StartNewFileTransferReq {
+    userid: string
+    targetUserId: string
+    metadata: TransferableFileMetadata[]
+}
+
+export interface AcceptFileTransferReq {
+    userid: string
+    senderId: string
+    transferId: string
+}
+
+export interface DeclineFileTransferReq {
+    userid: string
+    senderId: string
+    transferId: string
+}
+
+export interface FileTransferSendOfferRTCReq {
+    userid: string
+    peerId: string
+    transferId: string
+    offer: string
+}
+
+export interface FileTransferSendAnswerRTCReq {
+    userid: string
+    peerId: string
+    transferId: string
+    answer: string
+}
+
+export interface FileTransferSendICERTCReq {
+    userid: string
+    peerId: string
+    transferId: string
+    candidate: string
+}
+
+// Response schemas
+export interface StartNewFileTransferResp {
+    transferId: string
+}
+
+// WebSocket payloads
+export interface WSNewFileTransferPayload {
+    from: string
+    transferId: string
+    metadata: TransferableFileMetadata[]
+}
+
+export interface WSFileTransferAcceptedPayload {
+    transferId: string
+    rtcConfig: RTCConfiguration
+}
+
+export interface WSFileTransferDeclinedPayload {
+    transferId: string
+}
+
+export interface WSFileTransferRTCOfferPayload {
+    transferId: string
+    offer: string
+}
+
+export interface WSFileTransferRTCAnswerPayload {
+    transferId: string
+    answer: string
+}
+
+export interface WSFileTransferRTCIcePayload {
+    transferId: string
+    candidate: string
+}
+
+// DataChannel payloads
+export interface DCStartNewFilePayload {
+    fileId: string
+    fileIndex: number
+    fileName: string
+    totalChunks: number
+}
+
+export interface DCTransferFilePayload {
+    fileId: string
+    fileIndex: string
+    chunk: string
+}
+
+// Types
+export interface TransferableFileMetadata {
+    fileId: string
+    name: string
+    size: number
+}

src/domain/fileUploadService.schema.ts

@@ -33,8 +33,13 @@ export interface FileUploadRegistration {
 }
 
 export interface FileData {
+    fileId: string
     name: string
     extension: string
     type: string
     data: File
+}
+
+export interface FileUploadProgressListener {
+    fileProgressUpdate: (fileId: string, allChunks: number, chunksDone: number) => void
 }

src/domain/sessionManager.schema.ts

@@ -0,0 +1,19 @@
+import {PublicUserData} from "./common.schema";
+import {GIF, PersonalUserData} from "./userService.schema";
+
+export interface Session {
+    userData: PersonalUserData
+    token: string
+}
+
+export interface ValidateSessionReq {
+    token: string
+}
+
+export interface ValidateSessionResp {
+    validationOk: boolean
+}
+
+export interface UpdateUserDataReq {
+    userid: string
+}

src/domain/textChannelService.schema.ts

@@ -0,0 +1,138 @@
+import {Attachment, PublicUserData, TimeStamp} from "./common.schema";
+
+export interface GetMessageReq {
+    from: number
+    channelId: string
+    networkId: string
+    categoryId: string
+}
+
+export interface GetMessagePosReq {
+    messageId: string
+    channelId: string
+    networkId: string
+    categoryId: string
+}
+
+export interface GetPinnedMessagesReq {
+    channelId: string
+    networkId: string
+    categoryId: string
+}
+
+export interface EditMessageReq {
+    message: string
+    messageId: string
+    channelId: string
+    networkId: string
+    categoryId: string
+    userid: string
+}
+
+export interface FinishMessageReq {
+    uploadId: string | null
+    message: string
+    replyTo: string
+    replyToMessage: string
+    channelId: string
+    networkId: string
+    categoryId: string
+    userid: string
+}
+
+export interface ReadMessagesReq {
+    channelId: string
+    networkId: string
+    categoryId: string
+    userid: string
+}
+
+export interface PinMessageReq {
+    channelId: string
+    networkId: string
+    categoryId: string
+    messageId: string
+    userid: string
+    message: string
+}
+
+export interface UnpinMessageReq {
+    channelId: string
+    networkId: string
+    categoryId: string,
+    messageId: string,
+    userid: string
+}
+
+export interface DeleteMessagesReq {
+    messageIds: string[]
+    channelId: string
+    networkId: string
+    categoryId: string
+    userid: string
+}
+
+export interface JoinWsRoomReq {
+    connId: string
+    channelId: string
+    networkId: string
+    categoryId: string
+    userid: string
+}
+
+// Response schemas
+export interface GetMessagePosResp {
+    messagePos: number
+}
+
+// Types
+export interface Message {
+    msgid: string
+    author: PublicUserData
+    message: string
+    sent_at: TimeStamp
+    isEdited: boolean
+    channelId: string
+    networkId: string
+    categoryId: string
+    files: Attachment[]
+    seen: boolean
+    replyTo: string
+    replyToId: string
+    forwardedFrom: string
+    forwardedFromName: string
+}
+
+export interface PinnedMessage {
+    message: string
+    messageId: string
+}
+
+// WebSocket payloads
+export interface WSMessageDeletedPayload {
+    messageId: string
+}
+
+export interface WSMessageEditedPayload {
+    messageId: string
+    message: string
+}
+
+export interface WSMessagePinnedPayload {
+    channelId: string
+    networkId: string
+    categoryId: string
+    messageId: string
+    message: string
+}
+
+export interface WSMessagesReadPayload {
+    userid: string
+}
+
+export interface WSMessageUnpinnedPayload {
+    channelId: string
+    networkId: string
+    categoryId: string
+    messageId: string
+}

src/mocks/handlers/brcChan.http.ts

@@ -0,0 +1,11 @@
+import {http, HttpResponse} from "msw";
+import {GetRTCAccessResp} from "../../domain/callService.schema";
+import {StreamRegistry} from "../../domain/broadcastChannelService.schema";
+
+export const brcChanHandlers = [
+    http.get('*/network/channel/rtmpData', () => {
+        return HttpResponse.json(<StreamRegistry>{
+            status: "broadcasting_starting"
+        })
+    }),
+]

src/mocks/index.ts

@@ -6,6 +6,7 @@ import {fileUploadHandlers} from "./handlers/fUpl.http";
 import {chatHandlers} from "./handlers/chat.http";
 import {dmHandlers} from "./handlers/dm.http";
 import {userHandler} from "./handlers/user.http";
+import {brcChanHandlers} from "./handlers/brcChan.http";
 
 export const allHandlers = [
     ...authHandlers,
@@ -15,5 +16,6 @@ export const allHandlers = [
     ...fileUploadHandlers,
     ...chatHandlers,
     ...dmHandlers,
-    ...userHandler
+    ...userHandler,
+    ...brcChanHandlers
 ]

src/mocks/storage/database.ts

@@ -4,6 +4,9 @@ export class DatabaseMock implements DatabaseAPI {
     database: { [collection: string]: { [key: string]: string } } = {};
 
     set(collection: string, key: string, value: any) {
+        if (!this.database[collection]) {
+            this.database[collection] = {};
+        }
         this.database[collection][key] = JSON.stringify(value);
     }
 

src/mocks/storage/keyring.ts

@@ -11,11 +11,11 @@ export class KeyringMock implements KeyringAPI {
         return this.ring[key];
     }
 
+    getAll(): string[] {
+        return Object.keys(this.ring);
+    }
+
     delete(key: string) {
         delete this.ring[key];
     }
-
-    flush() {
-        this.ring = {};
-    }
 }

src/services/broadcastChannelService.test.ts

@@ -0,0 +1,11 @@
+import {describe, expect, it} from "vitest";
+import {BroadcastChannelService} from "./broadcastChannelService";
+
+describe("BroadcastChannelService", () => {
+    const service = new BroadcastChannelService("", "", "", "", "", () => {})
+
+    it("should get stream registry data", async () => {
+        const data = await service.getData()
+        expect(data.status).toBe("broadcasting_starting")
+    })
+})

src/services/broadcastChannelService.ts

@@ -0,0 +1,93 @@
+import {AxiosInstance, isAxiosError} from "axios";
+import {getClient} from "../core/http";
+import {MessageListener} from "../domain/websocket.schema";
+import {WebSocketHandler} from "../core/webSocketHandler";
+import {AcceptInviteReq} from "../domain/networkService.schema";
+import {GenericErrorBody} from "../domain/http.schema";
+import {
+    CreateServerReq,
+    GetRTMPDataReq,
+    JoinWebsocketRoomReq,
+    StreamRegistry
+} from "../domain/broadcastChannelService.schema";
+
+export class BroadcastChannelService {
+    userid: string
+    channelId: string
+    networkId: string
+    categoryId: string
+    client: AxiosInstance;
+
+    constructor(token: string, userid: string, networkId: string, categoryId: string, channelId: string, wsMessageListener: MessageListener) {
+        this.userid = userid;
+        this.channelId = channelId;
+        this.categoryId = categoryId;
+        this.networkId = networkId;
+        this.client = getClient(false).create({
+            headers: {
+                "Authorization": token,
+                "X-WS-ID": WebSocketHandler.getInstance().connId
+            }
+        })
+        WebSocketHandler.getInstance().registerService({
+            identifier: channelId,
+            onNewConnId: this.onNewConnId,
+            onNewMessage: wsMessageListener,
+        })
+    }
+
+    private onNewConnId(newConnId: string) {
+        console.log("NetworkService: New connection id")
+        this.client.defaults.headers["X-WS-ID"] = newConnId;
+    }
+
+    async getData(): Promise<StreamRegistry> {
+        try {
+            const resp = await this.client.get<StreamRegistry>(`network/channel/rtmpData?userid=${this.userid}&channelId=${this.channelId}&networkId=${this.networkId}&categoryId=${this.categoryId}`);
+            return resp.data
+        } catch (e) {
+            console.log(e)
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    async createServer(): Promise<StreamRegistry> {
+        try {
+            const resp = await this.client.post<StreamRegistry>("network/channel/createServer", <CreateServerReq>{
+                userid: this.userid,
+                channelId: this.channelId,
+                networkId: this.networkId,
+                type: "rtmp",
+                categoryId: this.categoryId,
+            });
+            return resp.data
+        } catch (e) {
+            console.log(e)
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    async joinWebSocketRoom(): Promise<void> {
+        try {
+            await this.client.post("v2/network/channel/joinWebSocketRoom", <JoinWebsocketRoomReq>{
+                userid: this.userid,
+                channelId: this.channelId,
+                networkId: this.networkId,
+                connId: WebSocketHandler.getInstance().connId,
+                categoryId: this.categoryId,
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+}

src/services/dmService.ts

@@ -13,7 +13,7 @@ import {
 } from "../domain/dmService.schema";
 import {NetworkInvite} from "../domain/networkService.schema";
 import {GenericErrorBody} from "../domain/http.schema";
-import {FileData} from "../domain/fileUploadService.schema";
+import {FileData, FileUploadProgressListener} from "../domain/fileUploadService.schema";
 import {FileUploadService} from "./fileUploadService";
 
 export class DMService {
@@ -133,12 +133,13 @@ export class DMService {
      * @param replyTo
      * @param replyToMessage
      * @param attachments
+     * @param progressListener
      */
-    async sendMessage(message: string, replyTo: string | null = null, replyToMessage: string | null = null, attachments: FileData[] | null = null): Promise<Message> {
+    async sendMessage(message: string, replyTo: string | null = null, replyToMessage: string | null = null, attachments: FileData[] | null = null, progressListener: FileUploadProgressListener | null = null): Promise<Message> {
         let uploadId = ""
         if (attachments) {
             const uploader = new FileUploadService(this.token)
-            uploadId = await uploader.uploadFiles(this.chatid, this.userid, attachments)
+            uploadId = await uploader.uploadFiles(this.chatid, this.userid, attachments, progressListener!)
         }
         try {
             const resp = await this.client.post<Message>("chat/dm/finishMessage", <FinishMessageReq>{

src/services/fileTransferService.ts

@@ -0,0 +1,156 @@
+import {DatabaseAPI} from "../storage/database";
+import {AxiosInstance, isAxiosError} from "axios";
+import {MessageListener} from "../domain/websocket.schema";
+import {getClient} from "../core/http";
+import {WebSocketHandler} from "../core/webSocketHandler";
+import {CreateNetworkReq, Network} from "../domain/networkService.schema";
+import {GenericErrorBody} from "../domain/http.schema";
+import {
+    AcceptFileTransferReq, DeclineFileTransferReq, FileTransferSendAnswerRTCReq,
+    FileTransferSendICERTCReq, FileTransferSendOfferRTCReq,
+    StartNewFileTransferReq,
+    StartNewFileTransferResp,
+    TransferableFileMetadata
+} from "../domain/fileTransferService.schema";
+
+export class FileTransferService {
+    userid: string;
+    peerId: string;
+    transferId: string = "";
+    client: AxiosInstance
+
+    constructor(userid: string, token: string, peerId: string) {
+        this.userid = userid;
+        this.peerId = peerId;
+        this.client = getClient(false).create({
+            headers: {
+                "Authorization": token,
+            }
+        })
+    }
+
+    /**
+     * Starts a new file transfer with the specified user. The new transferId will be saved automatically and not required to be provided later.
+     * @param transferableFiles
+     */
+    async startNew(transferableFiles: TransferableFileMetadata[]): Promise<string> {
+        try {
+            const resp = await this.client.post<StartNewFileTransferResp>("v2/chat/dm/startNewFileTransfer", <StartNewFileTransferReq>{
+                userid: this.userid,
+                targetUserId: this.peerId,
+                metadata: transferableFiles
+            });
+            this.transferId = resp.data.transferId
+            return resp.data.transferId
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Accepts the file transfer with the specified transferId. The transferId will be saved automatically and not required to be provided later.
+     * @param transferId
+     */
+    async accept(transferId: string): Promise<RTCConfiguration> {
+        try {
+            const resp = await this.client.post<RTCConfiguration>("v2/chat/dm/acceptFileTransfer", <AcceptFileTransferReq>{
+                userid: this.userid,
+                senderId: this.peerId,
+                transferId: transferId
+            });
+            this.transferId = transferId
+            return resp.data
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Declines the file transfer with the specified transferId.
+     * @param transferId
+     */
+    async decline(transferId: string): Promise<void> {
+        try {
+            await this.client.post("v2/chat/dm/declineFileTransfer", <DeclineFileTransferReq>{
+                userid: this.userid,
+                senderId: this.peerId,
+                transferId: transferId
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Forwards your RTC offer to the specified user.
+     * @param offer
+     */
+    async sendRtcOffer(offer: string): Promise<void> {
+        try {
+            await this.client.post("v2/chat/dm/sendRtcOfferFileTransfer", <FileTransferSendOfferRTCReq>{
+                userid: this.userid,
+                peerId: this.peerId,
+                transferId: this.transferId,
+                offer: offer,
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Forwards your RTC answer to the specified user.
+     * @param answer
+     */
+    async sendRtcAnswer(answer: string): Promise<void> {
+        try {
+            await this.client.post("v2/chat/dm/sendRtcAnswerFileTransfer", <FileTransferSendAnswerRTCReq>{
+                userid: this.userid,
+                peerId: this.peerId,
+                transferId: this.transferId,
+                answer: answer,
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Forwards your RTC ICE candidate to the specified user.
+     * @param candidate
+     */
+    async sendRtcICE(candidate: string): Promise<void> {
+        try {
+            await this.client.post("v2/chat/dm/sendRtcICEFileTransfer", <FileTransferSendICERTCReq>{
+                userid: this.userid,
+                peerId: this.peerId,
+                transferId: this.transferId,
+                candidate: candidate,
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+}

src/services/fileUploadService.test.ts

@@ -4,7 +4,9 @@ import {FileUploadService} from "./fileUploadService";
 describe("fileUploadService", () => {
     it('should upload files', async () => {
         const service = new FileUploadService("");
-        const uploadId = await service.uploadFiles("", "", [])
+        const uploadId = await service.uploadFiles("", "", [], {
+            fileProgressUpdate: () => {}
+        })
         expect(uploadId).toBe("MockUploadId")
     });
 })

src/services/fileUploadService.ts

@@ -1,6 +1,6 @@
 import {
     ChunkUploadReq,
-    FileData,
+    FileData, FileUploadProgressListener,
     FileUploadRegistration, FinishUploadReq,
     RegisterUploadReq,
     RegisterUploadResp
@@ -42,13 +42,14 @@ export class FileUploadService {
      * @param roomId chatid or channelId
      * @param userid
      * @param files
+     * @param listener
      */
-    async uploadFiles(roomId: string, userid: string, files: FileData[]): Promise<string> {
+    async uploadFiles(roomId: string, userid: string, files: FileData[], listener: FileUploadProgressListener): Promise<string> {
         let registrations: FileUploadRegistration[] = [];
 
         files.forEach(file => {
             registrations.push({
-                fileId: uuidv4(),
+                fileId: file.fileId,
                 name: file.name,
                 type: file.type,
                 size: file.data.size,
@@ -62,7 +63,7 @@ export class FileUploadService {
                 files: registrations,
             });
             for (let filesUploaded = 0; filesUploaded < files.length; filesUploaded++) {
-                await this.uploadFile(resp.data.uploadId, roomId, userid, files[filesUploaded], registrations[filesUploaded])
+                await this.uploadFile(resp.data.uploadId, roomId, userid, files[filesUploaded], registrations[filesUploaded], listener)
             }
             await this.finishUpload(roomId, userid, resp.data.uploadId)
             return resp.data.uploadId
@@ -92,7 +93,7 @@ export class FileUploadService {
         }
     }
 
-    private async uploadFile(uploadId: string, roomId: string, userid: string, file: FileData, registration: FileUploadRegistration): Promise<void> {
+    private async uploadFile(uploadId: string, roomId: string, userid: string, file: FileData, registration: FileUploadRegistration, listener: FileUploadProgressListener): Promise<void> {
         const chunkSize = this.calculateChunkSize(file.data.size);
         const totalChunks = Math.ceil(file.data.size / chunkSize);
 
@@ -104,6 +105,7 @@ export class FileUploadService {
             const chunk = new Uint8Array(arrayBuffer.slice(start, end));
             const base64 = this.uint8ToBase64(chunk);
             await this.uploadChunk(uploadId, roomId, userid, registration.fileId, base64);
+            listener.fileProgressUpdate(file.fileId, totalChunks, i)
         }
     }
 

src/services/sessionManager.ts

@@ -0,0 +1,133 @@
+import {PublicUserData} from "../domain/common.schema";
+import {DatabaseAPI} from "../storage/database";
+import {KeyringAPI} from "../storage/keyring";
+import {KeyValueAPI} from "../storage/keyvalue";
+import {Session, ValidateSessionReq, ValidateSessionResp} from "../domain/sessionManager.schema";
+import {AxiosInstance} from "axios";
+import {getClient} from "../core/http";
+import {PersonalUserData} from "../domain/userService.schema";
+
+export class SessionManager {
+    client: AxiosInstance;
+    database: DatabaseAPI;
+    keyring: KeyringAPI;
+    KeyValue: KeyValueAPI;
+
+    constructor(database: DatabaseAPI, keyring: KeyringAPI, KeyValue: KeyValueAPI) {
+        this.database = database;
+        this.keyring = keyring;
+        this.KeyValue = KeyValue;
+        this.client = getClient(false)
+    }
+
+    /**
+     * Saves the new session to the database and the keyring
+     * @param userData
+     * @param token
+     */
+    addSession(userData: PublicUserData, token: string): void {
+        this.database.set("sessions", userData.userid, JSON.stringify(userData))
+        this.keyring.set(userData.userid, token)
+    }
+
+    /**
+     * Loads all saved sessions
+     */
+    loadSessions(): Session[] {
+        const tokens = this.keyring.getAll()
+        const sessions: Session[] = []
+        tokens.forEach(token => {
+            const userData = this.database.get("sessions", token.split(".")[0])
+            if (userData) {
+                sessions.push({
+                    token: token,
+                    userData: JSON.parse(userData)
+                })
+            }
+        })
+
+        return sessions
+    }
+
+    /**
+     * Gets the preferred user set by the client
+     */
+    getPreferredUser(): string {
+        return this.KeyValue.get("preferredUser") ?? ""
+    }
+
+    /**
+     * Sets a new preferred user
+     * @param userid
+     */
+    setPreferredUser(userid: string): void {
+        this.KeyValue.set("preferredUser", userid)
+    }
+
+    /**
+     * Loads the preferred session by the client
+     */
+    loadPreferredSession() {
+        const sessions = this.loadSessions()
+        let preferredUser = this.getPreferredUser()
+        if (preferredUser == "") {
+            preferredUser = sessions[0].userData.userid
+            this.setPreferredUser(sessions[0].userData.userid)
+        }
+
+        const preferredSession = sessions.find(s => s.userData.userid == preferredUser)
+        if (preferredSession) {
+            return preferredSession
+        } else {
+            return sessions[0]
+        }
+    }
+
+    /**
+     * Validates and updates all sessions and returns with a new session list
+     * @param sessions
+     */
+    updateSessions(sessions: Session[]): Session[] {
+        sessions.forEach(async session => {
+            const index = sessions.indexOf(session)
+            if (!await this.validateSession(session.token)) {
+                this.database.delete("sessions", session.userData.userid)
+                this.keyring.delete(session.userData.userid)
+                sessions.splice(index, 1)
+            }
+
+            const updatedUserData = await this.updateUserData(session)
+            this.database.set("sessions", session.userData.userid, updatedUserData)
+            sessions[index] = updatedUserData
+        })
+
+        return sessions
+    }
+
+    private async validateSession(token: string): Promise<boolean> {
+        try {
+            const resp = await this.client.post<ValidateSessionResp>("v2/user/validateSession", <ValidateSessionReq>{
+                token: token,
+            })
+            return resp.data.validationOk
+        } catch (e) {
+            return true
+        }
+    }
+
+    private async updateUserData(session: Session): Promise<Session> {
+        const authenticatedClient = this.client.create({
+            headers: {
+                "Authorization": session.token,
+            }
+        })
+
+        try {
+            const resp = await authenticatedClient.get<PersonalUserData>(`user/byUseridPersonal?userid=${session.userData.userid}`)
+            session.userData = resp.data
+            return session
+        } catch (e) {
+            throw new Error("Session update error")
+        }
+    }
+}

src/services/textChannelService.ts

@@ -0,0 +1,280 @@
+import {DatabaseAPI} from "../storage/database";
+import {AxiosInstance, isAxiosError} from "axios";
+import {MessageListener} from "../domain/websocket.schema";
+import {getClient} from "../core/http";
+import {WebSocketHandler} from "../core/webSocketHandler";
+import {
+    DeleteMessagesReq,
+    EditMessageReq,
+    FinishMessageReq,
+    GetMessagePosResp, JoinWsRoomReq,
+    Message, PinMessageReq,
+    PinnedMessage, ReadMessagesReq, UnpinMessageReq
+} from "../domain/textChannelService.schema";
+import {NetworkInvite} from "../domain/networkService.schema";
+import {GenericErrorBody} from "../domain/http.schema";
+import {FileData, FileUploadProgressListener} from "../domain/fileUploadService.schema";
+import {FileUploadService} from "./fileUploadService";
+
+export class TextChannelServiceService {
+    userid: string;
+    networkId: string;
+    categoryId: string;
+    channelId: string;
+    token: string;
+    database: DatabaseAPI;
+    client: AxiosInstance
+
+    constructor(userid: string, token: string, networkId: string, categoryId: string, channelId: string, database: DatabaseAPI, wsMessageListener: MessageListener) {
+        this.userid = userid;
+        this.networkId = networkId;
+        this.categoryId = categoryId;
+        this.channelId = channelId;
+        this.database = database;
+        this.token = token;
+        this.client = getClient(false).create({
+            headers: {
+                "Authorization": token,
+                "X-WS-ID": WebSocketHandler.getInstance().connId
+            }
+        })
+        WebSocketHandler.getInstance().registerService({
+            identifier: channelId,
+            onNewConnId: this.onNewConnId,
+            onNewMessage: wsMessageListener,
+        })
+    }
+
+    private onNewConnId(newConnId: string) {
+        console.log("NetworkService: New connection id")
+        this.client.defaults.headers["X-WS-ID"] = newConnId;
+    }
+
+    /**
+     * Fetches all messages in the chat
+     * @param from
+     */
+    async get(from: number = 0): Promise<Message[]> {
+        try {
+            const resp = await this.client.get<Message[]>(`network/channel/messages?networkId=${this.networkId}&channelId=${this.channelId}&categoryId=${this.categoryId}&userid=${this.userid}&from=${from}`);
+            if (from == 0) {
+                this.database.set("networkmessages", this.channelId, JSON.stringify(resp.data))
+            }
+            console.log(resp.data, "ASD")
+            return resp.data
+        } catch (e) {
+            console.log(e)
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    getQuick(): Message[] {
+        const messages = this.database.get("networkmessages", this.channelId)
+        if (messages) {
+            return JSON.parse(messages)
+        } else {
+            throw new Error("No messages in database")
+        }
+    }
+
+    /**
+     * Fetches the position of the specified message which can be used in get() to fetch an old message with it's surrounding messages
+     * @param messageId
+     */
+    async getMessagePos(messageId: string): Promise<number> {
+        try {
+            const resp = await this.client.get<GetMessagePosResp>(`network/channel/getMessagePosition?networkId=${this.networkId}&channelId=${this.channelId}&categoryId=${this.categoryId}&userid=${this.userid}&messageId=${messageId}`);
+            return resp.data.messagePos
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Gets all messages pinned in the chat
+     */
+    async getPinnedMessages(): Promise<PinnedMessage[]> {
+        try {
+            const resp = await this.client.get<PinnedMessage[]>(`network/channel/pinnedMessages?networkId=${this.networkId}&channelId=${this.channelId}&categoryId=${this.categoryId}&userid=${this.userid}`);
+            return resp.data
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Edits the specified message
+     * @param messageId
+     * @param newMessage
+     */
+    async editMessage(messageId: string, newMessage: string): Promise<void> {
+        try {
+            const resp = await this.client.patch("network/channel/editMessage", <EditMessageReq>{
+                messageId: messageId,
+                networkId: this.networkId,
+                channelId: this.channelId,
+                categoryId: this.categoryId,
+                userid: this.userid,
+                message: newMessage
+            });
+            return resp.data
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Sends a new message to the chat
+     * @param message
+     * @param replyTo
+     * @param replyToMessage
+     * @param attachments
+     * @param progressListener
+     */
+    async sendMessage(message: string, replyTo: string | null = null, replyToMessage: string | null = null, attachments: FileData[] | null = null, progressListener: FileUploadProgressListener | null = null): Promise<Message> {
+        let uploadId = ""
+        if (attachments) {
+            const uploader = new FileUploadService(this.token)
+            uploadId = await uploader.uploadFiles(this.channelId, this.userid, attachments, progressListener!)
+        }
+        try {
+            const resp = await this.client.post<Message>("network/channel/finishMessage", <FinishMessageReq>{
+                message: message,
+                networkId: this.networkId,
+                channelId: this.channelId,
+                categoryId: this.categoryId,
+                replyTo: replyTo,
+                replyToMessage: replyToMessage,
+                userid: this.userid,
+                uploadId: uploadId,
+            });
+            return resp.data
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Reads all messages sent to you in the chat
+     */
+    async readMessages(): Promise<void> {
+        try {
+            await this.client.patch("network/channel/readMessages", <ReadMessagesReq>{
+                networkId: this.networkId,
+                channelId: this.channelId,
+                categoryId: this.categoryId,
+                userid: this.userid,
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Pins the specified message
+     * @param messageId
+     * @param message
+     */
+    async pinMessage(messageId: string, message: string): Promise<void> {
+        try {
+            const resp = await this.client.patch("network/channel/pinMessage", <PinMessageReq>{
+                messageId: messageId,
+                networkId: this.networkId,
+                channelId: this.channelId,
+                categoryId: this.categoryId,
+                userid: this.userid,
+                message: message
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Unpins the specified message
+     * @param messageId
+     */
+    async unpinMessage(messageId: string): Promise<void> {
+        try {
+            const resp = await this.client.patch("network/channel/unpinMessage", <UnpinMessageReq>{
+                messageId: messageId,
+                networkId: this.networkId,
+                channelId: this.channelId,
+                categoryId: this.categoryId,
+                userid: this.userid,
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Deletes the message(s)
+     * @param messageIds
+     */
+    async deleteMessages(messageIds: string[]): Promise<void> {
+        try {
+            const resp = await this.client.patch("network/channel/deleteMessages", <DeleteMessagesReq>{
+                networkId: this.networkId,
+                channelId: this.channelId,
+                categoryId: this.categoryId,
+                userid: this.userid,
+                messageIds: messageIds
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Joins the WebSocket room to start receiving realtime messages
+     */
+    async joinWebSocketRoom(): Promise<void> {
+        try {
+            const resp = await this.client.patch("network/channel/joinWebSocketRoom", <JoinWsRoomReq>{
+                networkId: this.networkId,
+                channelId: this.channelId,
+                categoryId: this.categoryId,
+                userid: this.userid,
+                connId: WebSocketHandler.getInstance().connId,
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+}

src/storage/keyring.ts

@@ -1,6 +1,6 @@
 export interface KeyringAPI {
     set(key: string, value: any): void;
     get(key: string): string;
+    getAll(): string[];
     delete(key: string): void;
-    flush(): void;
 }

src/storage/keyvalue.ts

@@ -0,0 +1,6 @@
+export interface KeyValueAPI {
+    set(key: string, value: any): void;
+    get(key: string): string;
+    delete(key: string): void;
+    flush(): void;
+}

tests/broadcastChannelService.test.ts

@@ -0,0 +1,29 @@
+import {describe, expect, it} from "vitest";
+import {BroadcastChannelService} from "../src/services/broadcastChannelService";
+
+const BRC_CHAN_SERVICE_TESTING_NETWORK_ID = "000000000000000000000000"
+const BRC_CHAN_SERVICE_TESTING_USER_ID = "000000000000000000000000"
+const BRC_CHAN_SERVICE_TESTING_CHANNEL_ID = "333333333333333333333333"
+const BRC_CHAN_SERVICE_TESTING_TOKEN = "testingToken"
+const BRC_CHAN_SERVICE_TESTING_CATEGORY_ID = "111111111111111111111111"
+
+describe("BroadcastChannelService Integration Testing", () => {
+    const service = new BroadcastChannelService(
+        BRC_CHAN_SERVICE_TESTING_TOKEN,
+        BRC_CHAN_SERVICE_TESTING_USER_ID,
+        BRC_CHAN_SERVICE_TESTING_NETWORK_ID,
+        BRC_CHAN_SERVICE_TESTING_CATEGORY_ID,
+        BRC_CHAN_SERVICE_TESTING_CHANNEL_ID,
+        (action, data) => {}
+    )
+
+    it('should create a new server and fetch it', async () => {
+        await service.createServer()
+        const registry = await service.getData()
+        expect(registry.status).toBe("idling")
+    });
+
+    it('should join ws room', async () => {
+        await service.joinWebSocketRoom()
+    });
+})

tests/fileUploadService.test.ts

@@ -4,6 +4,7 @@ import {environment, SDKConfig} from "../src/core/environment";
 import {getClient} from "../src/core/http";
 import {FileData} from "../src/domain/fileUploadService.schema";
 import axios from "axios";
+import {v4 as uuidv4} from 'uuid';
 
 describe("FileUploadService Integration Testing", () => {
     const FILE_UPL_SERVICE_TESTING_USER_ID = "000000000000000000000000"
@@ -21,12 +22,16 @@ describe("FileUploadService Integration Testing", () => {
             FILE_UPL_SERVICE_TESTING_USER_ID,
             [
                 {
+                    fileId: uuidv4(),
                     name: "filename",
                     type: "image",
                     extension: "jpeg",
                     data: new File([response.data], "filename", { type: "image/jpeg" })
                 }
-            ]
+            ],
+            {
+                fileProgressUpdate: () => {},
+            }
         )
     });
 })

tests/networkService.test.ts

@@ -56,12 +56,6 @@ describe("NetworkService Integration Testing", () => {
         expect(category.name).toBe(catName)
     });
 
-    it('should delete category', async () => {
-        await service.deleteCategory(NETWORK_SERVICE_TESTING_CATEGORY_ID)
-        const networks = await service.get()
-        expect(networks[0].categories.length).toBe(0)
-    });
-
     it('should move category', async () => {
         await service.createCategory("Test name", "Test desc")
         await service.moveCategory(0, 1)
@@ -74,7 +68,7 @@ describe("NetworkService Integration Testing", () => {
     });
 
     it('should create rank', async () => {
-        const rankName = faker.internet.displayName()
+        const rankName = faker.internet.displayName().substring(0, 10)
         const rank = await service.createRank(rankName, <RGB>{r: 0, g: 0, b: 0}, null)
         expect(rank.name).toBe(rankName)
     });

tests/pictureService.test.ts

@@ -24,7 +24,7 @@ describe("PictureService Integration Test", () => {
     });
 
     it('should create an album', async () => {
-        const albumName = faker.internet.displayName()
+        const albumName = faker.internet.displayName().substring(0, 10)
         await service.createAlbum(albumName)
         const uploads = await service.get()
         expect(uploads.pictures[1].name).toBe(albumName)

tests/textChannelService.test.ts

@@ -0,0 +1,66 @@
+import {describe, expect, it} from "vitest";
+import {DMService} from "../src/services/dmService";
+import {ChatService} from "../src/services/chatService";
+import {DatabaseMock} from "../src/mocks/storage/database";
+import {faker} from "@faker-js/faker/locale/en";
+import {TextChannelServiceService} from "../src/services/textChannelService";
+
+describe("DmService Integration Testing", () => {
+    const TXT_CHAN_SERVICE_TESTING_CHANNEL_ID = "222222222222222222222222"
+    const TXT_CHAN_SERVICE_TESTING_USER_ID = "000000000000000000000000"
+    const TXT_CHAN_SERVICE_TESTING_MESSAGE_ID = "111111111111111111111111"
+    const TXT_CHAN_SERVICE_TESTING_TOKEN = "testingToken"
+    const NETWORK_SERVICE_TESTING_NETWORK_ID = "000000000000000000000000"
+    const NETWORK_SERVICE_TESTING_CATEGORY_ID = "111111111111111111111111"
+
+    const service = new TextChannelServiceService(
+        TXT_CHAN_SERVICE_TESTING_USER_ID,
+        TXT_CHAN_SERVICE_TESTING_TOKEN,
+        NETWORK_SERVICE_TESTING_NETWORK_ID,
+        NETWORK_SERVICE_TESTING_CATEGORY_ID,
+        TXT_CHAN_SERVICE_TESTING_CHANNEL_ID,
+        new DatabaseMock(),
+        () => {}
+    )
+
+    it('should get messages', async () => {
+        const messages = await service.get()
+        expect(messages[0].message).toBe("This is a message")
+        expect(messages[0].isEdited).toBeTruthy()
+    });
+
+    it('should get message position', async () => {
+        const pos = await service.getMessagePos(TXT_CHAN_SERVICE_TESTING_MESSAGE_ID)
+        expect(pos).toBe(0)
+    });
+
+    it('should edit message', async () => {
+        const newMessage = faker.lorem.paragraph()
+        await service.editMessage(TXT_CHAN_SERVICE_TESTING_MESSAGE_ID, newMessage)
+        const messages = await service.get()
+        expect(messages[0].message).toBe(newMessage)
+    });
+
+    it('should send a message', async () => {
+        const message = faker.lorem.paragraph()
+        const newMessage = await service.sendMessage(message)
+        expect(newMessage.message).toBe(message)
+    });
+
+    it('should read messages', async () => {
+        await service.readMessages()
+    });
+
+    it('should pin and unpin messages', async () => {
+        let pinnedMessages = await service.getPinnedMessages()
+        expect(pinnedMessages.length).toBe(0)
+
+        await service.pinMessage(TXT_CHAN_SERVICE_TESTING_MESSAGE_ID, "message")
+        pinnedMessages = await service.getPinnedMessages()
+        expect(pinnedMessages.length).toBe(1)
+
+        await service.unpinMessage(TXT_CHAN_SERVICE_TESTING_MESSAGE_ID)
+        pinnedMessages = await service.getPinnedMessages()
+        expect(pinnedMessages.length).toBe(0)
+    });
+})

tsconfig.json

@@ -4,6 +4,7 @@
     "module": "commonjs",
     "esModuleInterop": true,
     "forceConsistentCasingInFileNames": true,
+    "declaration": true,
     "strict": true,
     "skipLibCheck": true,
     "outDir": "dist"