@up-im/medotvet_sdk 0.0.1

package/dist/storage/user.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserStorage = void 0;
+const jwt_decode_1 = require("jwt-decode");
+const default_1 = require("./default");
+const userLogout_1 = require("../eventBus/userLogout");
+class UserStorage {
+    constructor(storage) {
+        this.user = null; // = user
+        this.accessToken = null;
+        this.accessTokenExp = null; //строк действия accessToken
+        this.localTimeDiff = 0; //смещение локального времени в браузере
+        this.storage = storage || default_1.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 userLogout_1.eventBusUserLogout.broadcast();
+            }
+        }
+        return null;
+    }
+    async setUser(accessToken, refreshToken) {
+        this.user = (0, jwt_decode_1.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 }) {
+        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;
+    }
+    getCurrentTime() {
+        return Date.now() + this.localTimeDiff;
+    }
+    async getAccessToken() {
+        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 = (0, jwt_decode_1.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() {
+        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());
+    }
+}
+exports.UserStorage = UserStorage;

package/dist/utils/queryString.d.ts

@@ -0,0 +1,3 @@
+export declare function queryString(initialObj: {
+    [key: string]: any;
+}): any;

package/dist/utils/queryString.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.queryString = queryString;
+function queryString(initialObj) {
+    const reducer = (obj, parentPrefix = null) => (prev, key) => {
+        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/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@up-im/medotvet_sdk",
+  "version": "0.0.1",
+  "description": "",
+  "main": "dist/index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "build": "tsc"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Oreen/apcheki_sdk.git"
+  },
+  "author": "Maximum-MK, LLC",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/Oreen/apcheki_sdk/issues"
+  },
+  "homepage": "https://www.up-im.ru",
+  "dependencies": {
+    "jwt-decode": "^4.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.14.10",
+    "typescript": "^5.5.3"
+  },
+  "exports": {
+    ".": "./dist/index.js",
+    "./interfaces/*": "./dist/interfaces/*.js"
+  }
+}

package/src/api/abstract.ts

@@ -0,0 +1,136 @@
+import { eventBusUserLogout } from "../eventBus/userLogout"
+import { ApiError } from "../http/apiError"
+import { apiRouteUserRefresh } from "../http/apiRoute"
+import { iUserTokens } from "../interfaces/iUserTokens"
+import { UserStorage } from "../storage/user"
+
+export class ApiAbstract {
+    protected host: string
+    protected userStorage: UserStorage
+    private static isTokenUpdating = false
+
+    constructor({
+        host,
+        userStorage
+    }: {
+        host: string,
+        userStorage: UserStorage
+    }) {
+        this.host = host
+        this.userStorage = userStorage
+    }
+
+    protected async fetcher<TResponse>({
+        route,
+        postBody = null,
+        options
+    }: {
+        route: string,
+        postBody?: { [key: string]: any } | null,
+        options?: RequestInit & {
+            noConsoleError?: boolean
+            addToken?: boolean
+        }
+    }): Promise<TResponse> {
+        const formData = new FormData();
+        if (postBody) {
+            for (let key in postBody) {
+                if (postBody[key] instanceof FileList) {
+                    for (const value of postBody[key]) {
+                        formData.append(key + '[]', value);
+                    }
+                } else if (Array.isArray(postBody[key])) {
+                    for (const value of postBody[key]) {
+                        if (value !== null && typeof value == "object") {
+                            formData.append(key + '[]', JSON.stringify(value));
+                        } else {
+                            formData.append(key + '[]', value);
+                        }
+                    }
+                } else if (typeof postBody[key] == "object") {
+                    formData.append(key, JSON.stringify(postBody[key]));
+                } else {
+                    formData.append(key, postBody[key]);
+                }
+            }
+        }
+        const headers: { [key: string]: string } = {}
+        if (options?.addToken) {
+            const token = await this.getToken()
+            headers["Authorization"] = `Bearer ${token}`
+        } else if (route.startsWith('/user') && !!postBody) {
+            headers["timestamp"] = Date.now().toString()
+        }
+
+        try {
+            const res = await fetch(this.host + "/api" + route, {
+                headers: headers,
+                method: postBody ? "POST" : "GET",
+                body: postBody ? formData : null,
+                credentials: "include",
+                ...options
+            })
+
+            if (!res.ok) {
+                if (res.status == 413) throw new ApiError(res.status, "Слишком большой размер файла")
+                if (res.status == 401) {
+                    await this.userStorage.clearUser()
+                    await eventBusUserLogout.broadcast()
+                }
+                if (res.status == 404 && !postBody) {
+                    if (!options?.noConsoleError) console.warn(`not_found: ${this.host + "/api" + route}`)
+                }
+                try {
+                    //пробуем расшифровать json с ошибкой
+                    const answer = await res.json()
+                    const error = new ApiError(res.status, answer.message)
+                    throw error
+                } catch (error: unknown) {
+                    //ошибка расшифровки json
+                    if (!options?.noConsoleError) console.warn({ url: this.host + "/api" + route })
+                    if (!(error instanceof ApiError)) throw new ApiError(res.status, res.statusText)
+                    throw error
+                }
+            }
+
+            return res.json()
+        } catch (error) {
+            if (error instanceof Error && error.message.toLowerCase().includes("fail")) throw new ApiError(0, "Нет соединения с интернетом")
+            throw error
+        }
+    }
+
+    protected async getToken(): Promise<string | null> {
+        const accessToken = await this.userStorage.getAccessToken()
+        if (accessToken) return accessToken
+
+        const refreshToken = await this.userStorage.getRefreshToken()
+        if (refreshToken) {
+            //перевыпуск пары токенов
+            if (ApiAbstract.isTokenUpdating) {//дедубликация запросов на обновление токена
+                await new Promise(r => setTimeout(r, 100));//sleep
+                return await this.getToken()
+            }
+            ApiAbstract.isTokenUpdating = true
+            try {
+                const data: iUserTokens = await this.fetcher({
+                    route: apiRouteUserRefresh,
+                    postBody: { refreshToken: refreshToken }
+                })
+                await this.userStorage.setUser(data.accessToken, data.refreshToken)
+                ApiAbstract.isTokenUpdating = false
+                return data.accessToken
+            } catch (error: unknown) {
+                console.error(error)
+                if (error instanceof ApiError) {
+                    if (error.status === 404) {//токен не найден
+                        await this.userStorage.clearUser()
+                        await eventBusUserLogout.broadcast()
+                    }
+                }
+            }
+            ApiAbstract.isTokenUpdating = false
+        }
+        return null
+    }
+}

package/src/api/bookmarks.ts

@@ -0,0 +1,109 @@
+import { ApiAbstract } from "./abstract";
+import { apiRouteBookmarksAdd, apiRouteBookmarksCount, apiRouteBookmarksGet, apiRouteBookmarksRemove } from "../http/apiRoute";
+
+import { ItemType } from "../interfaces/itemType";
+import { iBookmark } from "../interfaces/iBookmark";
+import { ApiError } from "../http/apiError";
+
+export class ApiBookmarks extends ApiAbstract {
+    private cache = new Map<string, string | false>()//false - если данные не получены с сервера по ключу 
+    private timeout: ReturnType<typeof setTimeout> | undefined = undefined
+    private requestKeys = new Set<string>()
+    private total: number | null = null
+
+    /**
+     * принимает id акции (не товара) который находится в поле id метода возвращаемых товаров getCatalogList. В методе есть дебаунсер, что позволяет его вызвать для каждого товара на странице сделав только 1 запрос на сервер 
+     * @param {number} props.sku - id акции (не товара)
+     */
+    async inBookmarks({ skuId }: { skuId: number }) {
+        if (!skuId || skuId <= 0) return false
+        if (!await this.userStorage.isAuth()) return false
+        const key = `${ItemType.CATALOG_SKU}-${skuId}`
+        return await this.collectKeys(key)
+    }
+
+    private async collectKeys(key: string): Promise<boolean> {
+        //has cache
+        if (this.cache.has(key)) {
+            const val = this.cache.get(key)
+            if (val !== false) return true
+            return false
+        }
+        //no cache
+        //собираем включи для 1 запроса со всех вызовов
+        if (!this.requestKeys.has(key)) {
+            if (this.timeout) clearTimeout(this.timeout)
+            this.requestKeys.add(key)
+            this.timeout = setTimeout(async () => {
+                if (!this.requestKeys.size) return
+                //все компоненты отрендерены, ключи все запрошены, можно выполнять запрос
+                try {
+                    const arrFromRequestKeys = Array.from(this.requestKeys)
+                    const data = await this.fetcher<iBookmark[]>({
+                        route: apiRouteBookmarksGet,
+                        postBody: { itemKeys: arrFromRequestKeys },
+                        options: { addToken: true }
+                    })
+                    for (const requestKey of arrFromRequestKeys) {
+                        const find = data.find(it => it.item_key == requestKey)
+                        this.cache.set(requestKey, find?.item_key || false)
+                    }
+                } catch (error) {
+                    this.cache.set(key, false)
+                    console.error(error)
+                }
+                this.requestKeys.clear()//очистка очереди запросов
+            }, 200)
+        }
+        //ждем последнего запроса
+        await new Promise(r => setTimeout(r, 300));//sleep
+        return await this.collectKeys(key)//на следующем крузе вернется результат из кэша
+    }
+
+    /**
+     * добавление \ удаление из избранного
+     * @param {number} props.sku - id акции (не товара)
+     * @param {UserStatEvent} props.isAdd - признак добавление или удаление
+     */
+    async mutate({ skuId, isAdd }: { skuId: number, isAdd: boolean }) {
+        if (!skuId || skuId <= 0) return
+        if (!await this.userStorage.isAuth()) throw new ApiError(401, "Пользователь не авторизован")
+        try {
+            await this.fetcher({
+                route: isAdd
+                    ? apiRouteBookmarksAdd
+                    : apiRouteBookmarksRemove,
+                postBody: {
+                    itemType: ItemType.CATALOG_SKU,
+                    itemId: skuId
+                },
+                options: {
+                    addToken: true
+                }
+            })
+        } catch (error: unknown) {
+            console.error(error)
+        }
+        const key = `${ItemType.CATALOG_SKU}-${skuId}`
+        this.cache.set(key, isAdd ? key : false)
+        this.total = (this.total ?? 0) + (isAdd ? 1 : -1)
+    }
+
+    /**
+     * возвращает кол-во товаров в избранном или null в случае ошибки
+     */
+    async getTotal() {
+        if (this.total !== null) return this.total
+        if (!await this.userStorage.isAuth()) return null
+        try {
+            const total = await this.fetcher<number>({
+                route: apiRouteBookmarksCount,
+                options: { addToken: true }
+            })
+            this.total = total
+        } catch (error) {
+            console.error(error)
+        }
+        return this.total
+    }
+}

package/src/api/chat.ts

@@ -0,0 +1,127 @@
+import { iMessage, iMessageOutgoing, iMessageView } from "../interfaces/iMessage"
+import { ApiAbstract } from "./abstract"
+import { WebSocketClient } from "../service/webSocketClient"
+import { UserStorage } from "../storage/user"
+import { ApiError } from "../http/apiError"
+import { eventBusUserLogout } from "../eventBus/userLogout"
+import { apiRouteChatUnread } from "../http/apiRoute"
+//import { eventBusUserLogin } from "../eventBus/userLogin"
+
+export class ApiChat extends ApiAbstract {
+    private client: WebSocketClient
+    private messageHistory: iMessage[][] = []
+    private messageSubscriptions = new Set<(messages: iMessage[]) => void>()
+
+    constructor({
+        host,
+        wsHost,
+        userStorage
+    }: {
+        host: string,
+        wsHost: string,
+        userStorage: UserStorage
+    }) {
+        super({ host, userStorage });
+        this.client = new WebSocketClient(wsHost)
+        this.client.onOpen(async () => await this.auth())
+        this.client.onMessage(message => {
+            //prepare
+            const data: iMessage[] = JSON.parse(message)
+            if (!Array.isArray(data)) {
+                console.error('Входящее сообщения должны быть массивом', data)
+                return
+            }
+            for (const item of data) {
+                if ("date" in item) item.date = new Date(item.date)
+            }
+            //broadcast
+            for (const callback of Array.from(this.messageSubscriptions)) {
+                callback(data)
+            }
+            //Последние 10 групп сообщений с сервера для новых подписчиков
+            this.messageHistory.push(data)
+            if (this.messageHistory.length > 10) {
+                this.messageHistory.splice(0, this.messageHistory.length - 10);
+            }
+        })
+        // eventBusUserLogin.subscribe(async () => this.client.connect())
+        // this.userStorage.isAuth().then(isAuth => {
+        //     if (isAuth) this.client.connect()
+        // })
+        eventBusUserLogout.subscribe(async () => this.client.close())
+    }
+
+    private async auth() {
+        const token = await this.getToken()
+        if (!token) {
+            console.error("User token for WebSocket empty")
+            return
+        }
+        this.client.send(JSON.stringify({ token }), true)
+    }
+
+    messageSubscribe(callback: (messages: iMessage[]) => void) {
+        this.messageSubscriptions.add(callback)
+        //Последние 10 групп сообщений с сервера для новых подписчиков
+        for (const history of this.messageHistory) callback(history)
+        return () => { this.messageSubscriptions.delete(callback) }
+    }
+
+    async sendMessage({ text, file }: { text: string, file?: FileList | File | null }) {
+        const user = await this.userStorage?.getUser()
+        if (!user) throw new ApiError(401, "Пользователь не авторизован")
+        if (user.role !== 0) throw new ApiError(400, "Для тестирования чата авторизуйтесь под обычного пользователя")
+
+        const convertToBase64 = (file: File): Promise<string> => {
+            return new Promise((resolve, reject) => {
+                const reader = new FileReader();
+                reader.onload = () => resolve(reader.result as string);
+                reader.onerror = reject;
+                reader.readAsDataURL(file);
+            })
+        }
+        const firstFile = file instanceof FileList
+            ? Array.from(file)?.pop()
+            : file
+        const message: iMessageOutgoing = {
+            route: "/message",
+            text,
+            file: firstFile ? await convertToBase64(firstFile) : undefined
+        }
+        this.client.send(JSON.stringify(message))
+    }
+    sendView({ id }: { id: number }) {
+        const message: iMessageView = {
+            route: "/view",
+            message_id: id
+        }
+        this.client.send(JSON.stringify(message))
+    }
+    /**
+    * Получить количество непрочитанных сообщений через обычное API
+    */
+    async getUnread() {
+        if (!await this.userStorage.isAuth()) throw new ApiError(401, "Пользователь не авторизован")
+        const data = await this.fetcher<{ unread: number }>({
+            route: apiRouteChatUnread,
+            options: { addToken: true }
+        })
+        return data.unread
+    }
+    // getDialogs({page}:{page: number}) {//оставим для оптимизации если диалогов будет много
+    //     this.client.send(JSON.stringify({
+    //         route: "/get/dialogs",
+    //         page,
+    //     }))
+    // }
+    getMessages({ page }: { page: number }) {
+        this.client.send(JSON.stringify({
+            route: "/get/messages",
+            page,
+        }))
+    }
+
+    disconnect() {
+        this.client.close()
+    }
+}