@up-im/medotvet_sdk 0.0.1

package/src/service/webSocketClient.ts

@@ -0,0 +1,94 @@
+type OpenCallback = () => Promise<void>;
+type MessageCallback = (message: string) => void;
+
+export class WebSocketClient {
+    private url: string;
+    private websocket: WebSocket | null;
+    private reconnectInterval: number;
+    private reconnectAttempts: number;
+    private maxReconnectAttempts: number;
+    private isReconnecting: boolean = false
+    private sendMessageBuffer: string[] = []
+    private openCallback: OpenCallback | null = null
+    private messageCallback: MessageCallback | null = null
+
+    constructor(url: string, reconnectInterval = 1000, maxReconnectAttempts = 1000) {
+        this.url = url;
+        this.websocket = null;
+        this.reconnectInterval = reconnectInterval;
+        this.reconnectAttempts = 0;
+        this.maxReconnectAttempts = maxReconnectAttempts;
+    }
+
+    connect() {
+        this.websocket = new WebSocket(this.url);
+
+        this.websocket.onopen = async () => {
+            console.log('Connected to WebSocket server');
+            this.reconnectAttempts = 0;
+            if (this.openCallback) await this.openCallback();//auth
+            this.send();//send MessageBuffer
+        };
+
+        this.websocket.onmessage = (event: MessageEvent<string>) => {
+            console.log('Received message:', event.data);
+            if (this.messageCallback) this.messageCallback(event.data);
+        };
+
+        this.websocket.onerror = (event) => {
+            console.error('WebSocket error:', event);
+            this.reconnect();
+        };
+
+        this.websocket.onclose = (event) => {
+            console.log('WebSocket connection closed:', event);
+            if (event.code != 3001) this.reconnect();
+        };
+    }
+
+    private reconnect() {
+        if (this.isReconnecting) return
+        this.isReconnecting = true
+        if (this.reconnectAttempts < this.maxReconnectAttempts) {
+            this.reconnectAttempts++;
+            console.log(`Reconnecting... attempt ${this.reconnectAttempts}`);
+            setTimeout(() => {
+                this.isReconnecting = false
+                this.connect()
+            }, this.reconnectInterval);
+        } else {
+            this.isReconnecting = false
+            console.error('Max reconnect attempts reached');
+        }
+    }
+
+    public send(message?: string, priority?: boolean) {
+        if (message && priority) this.sendMessageBuffer.unshift(message)
+        if (message && !priority) this.sendMessageBuffer.push(message)
+        if (this.websocket && this.websocket.readyState === WebSocket.OPEN) {
+            while (this.sendMessageBuffer.length) {
+                this.websocket.send(this.sendMessageBuffer.shift()!);
+            }
+        } else {
+            console.log('WebSocket is not open. reconnect');
+            this.reconnect();
+        }
+    }
+
+    // Устанавливаем callback для открытия соединения
+    public onOpen(callback: OpenCallback) {
+        this.openCallback = callback;
+    }
+
+    // Устанавливаем callback для обработки входящих сообщений
+    public onMessage(callback: MessageCallback) {
+        this.messageCallback = callback;
+    }
+
+    // Закрытие WebSocket соединения
+    public close() {
+        if (this.websocket && this.websocket.readyState === WebSocket.OPEN) {
+            this.websocket.close(3001, "Manual disconnect");
+        }
+    }
+}

package/src/storage/default.ts

@@ -0,0 +1,7 @@
+import { iStorage } from "../interfaces/iStorage";
+
+export const storageDefault: iStorage = {
+    set: async (key, data) => localStorage.setItem(key, data),
+    get: async (key) => localStorage.getItem(key),
+    remove: async (key) => localStorage.removeItem(key),
+}

package/src/storage/user.ts

@@ -0,0 +1,109 @@
+import { jwtDecode } from "jwt-decode"
+import { iStorage } from "../interfaces/iStorage"
+import { iUserData } from "../interfaces/iUserData"
+import { storageDefault } from "./default"
+import { eventBusUserLogout } from "../eventBus/userLogout"
+
+export class UserStorage {
+    protected storage: iStorage
+    private user: iUserData | null = null// = user
+    private accessToken: string | null = null
+    private accessTokenExp: number | null = null//строк действия accessToken
+    private localTimeDiff: number = 0//смещение локального времени в браузере
+
+    constructor(storage?: iStorage) {
+        this.storage = storage || storageDefault
+    }
+
+    async getUser() {
+        if (this.user) return this.user
+        if (typeof window === 'undefined') return null//SSR
+        const userStorage = await this.storage.get('user')
+        if (typeof userStorage != "string" && userStorage !== null && userStorage !== undefined) {
+            throw new Error("Из storage получено некорректное значение пользователя. Должно быть строкой или null")
+        }
+        if (userStorage) {
+            const userStorageDecoded = JSON.parse(userStorage)
+            // check exp
+            if (this.getCurrentTime() < userStorageDecoded.exp * 1000) {//тут срок refreshToken
+                this.user = userStorageDecoded
+                return this.user
+            } else {//закончился срок refreshToken
+                await this.clearUser()
+                await eventBusUserLogout.broadcast()
+            }
+        }
+        return null
+    }
+
+    async setUser(accessToken: string, refreshToken: string) {
+        this.user = jwtDecode(refreshToken)
+        await this.storage.set('accessToken', accessToken)
+        await this.storage.set('refreshToken', refreshToken)
+        await this.storage.set('user', JSON.stringify(this.user))
+        return this.user
+    }
+
+    async saveUser({ firstname, lastname }: { firstname?: string, lastname?: string }) {
+        if (this.user) {
+            if (firstname) this.user.firstname = firstname
+            if (lastname) this.user.lastname = lastname
+            await this.storage.set('user', JSON.stringify(this.user))
+        }
+        return this.user
+    }
+
+    async clearUser() {
+        await this.storage.remove('accessToken')
+        await this.storage.remove('refreshToken')
+        await this.storage.remove('user')
+        this.user = null
+        this.accessToken = null
+        this.accessTokenExp = null
+        this.localTimeDiff = 0
+    }
+
+    private getCurrentTime() {
+        return Date.now() + this.localTimeDiff
+    }
+
+    async getAccessToken(): Promise<string | null> {
+        if (typeof window === 'undefined') return null//SSR
+
+        //кэш с проверкой срока действия
+        if (this.accessToken && this.accessTokenExp && this.localTimeDiff && this.getCurrentTime() < this.accessTokenExp * 1000) {
+            return this.accessToken
+        }
+        //создаем кэш
+        this.accessToken = await this.storage.get('accessToken')
+        if (typeof this.accessToken != "string" && this.accessToken !== null && this.accessToken !== undefined) {
+            throw new Error("Из storage получено некорректное значение accessToken. Должно быть строкой или null")
+        }
+        if (!this.accessToken) return null;//токена нет
+        const accessTokenDecoded: iUserData | null = jwtDecode(this.accessToken)
+        this.localTimeDiff = accessTokenDecoded?.localTimeDiff ?? 0
+        this.accessTokenExp = accessTokenDecoded?.exp ?? null
+        if (accessTokenDecoded?.exp && this.getCurrentTime() < accessTokenDecoded.exp * 1000) {
+            return this.accessToken
+        }
+        return null
+    }
+
+    async getRefreshToken(): Promise<string | null> {
+        if (typeof window === 'undefined') return null//SSR
+
+        const refreshTokenData = await this.getUser()//возвращает раскодированный refreshToken и проверяет его дату
+        if (refreshTokenData) {
+            const refreshToken = await this.storage.get('refreshToken')
+            if (typeof refreshToken != "string" && refreshToken !== null && refreshToken !== undefined) {
+                throw new Error("Из storage получено некорректное значение refreshToken. Должно быть строкой или null")
+            }
+            if (refreshToken) return refreshToken
+        }
+        return null
+    }
+
+    async isAuth() {
+        return !!(await this.getUser())
+    }
+}

package/src/utils/queryString.ts

@@ -0,0 +1,22 @@
+export function queryString(initialObj: { [key: string] : any} ) {
+    const reducer = (obj: { [key: string] : any}, parentPrefix: string | null = null) => (prev:any, key:string) => {
+        const val = obj[key];
+        key = encodeURIComponent(key);
+        const prefix = parentPrefix ? `${parentPrefix}[${key}]` : key;
+
+        if (val == null || typeof val === 'function') {
+            prev.push(`${prefix}=`);
+            return prev;
+        }
+
+        if (['number', 'boolean', 'string'].includes(typeof val)) {
+            prev.push(`${prefix}=${encodeURIComponent(val)}`);
+            return prev;
+        }
+
+        prev.push(Object.keys(val).reduce(reducer(val, prefix), []).join('&'));
+        return prev;
+    };
+
+    return Object.keys(initialObj).reduce(reducer(initialObj), []).join('&');
+}

package/tsconfig.json

@@ -0,0 +1,27 @@
+{
+  "compilerOptions": {
+    "target": "es2021",
+    "module": "NodeNext",
+    "declaration": true,
+    "outDir": "./dist",
+    "noEmit": false,
+    "strict": true,
+    "noImplicitAny": true,
+    "strictNullChecks": true,
+    "strictFunctionTypes": true,
+    "strictBindCallApply": true,
+    "strictPropertyInitialization": true,
+    "noImplicitThis": true,
+    "alwaysStrict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+    "noPropertyAccessFromIndexSignature": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "skipLibCheck": true
+  }
+}