squarefi-bff-api-module 1.32.1 → 1.32.2

package/dist/hooks/useSupabaseSubscription/types.d.ts

@@ -0,0 +1,16 @@
+export interface SubscriptionConfig {
+    channelName: string;
+    table: string;
+    schema?: string;
+    event?: 'INSERT' | 'UPDATE' | 'DELETE' | '*';
+    filter?: string;
+}
+export interface UseSupabaseSubscriptionProps {
+    config: SubscriptionConfig;
+    callback: (payload?: unknown) => void;
+    enabled?: boolean;
+    key?: string;
+}
+export interface UseWalletTransactionsSubscriptionProps extends Omit<UseSupabaseSubscriptionProps, 'config'> {
+    walletId: string | undefined;
+}

package/dist/hooks/useSupabaseSubscription/types.js

@@ -0,0 +1 @@
+export {};

package/dist/hooks/useSupabaseSubscription/useSupabaseSubscription.d.ts

@@ -0,0 +1,5 @@
+import { UseSupabaseSubscriptionProps } from './types';
+export declare const useSupabaseSubscription: ({ config, callback, enabled, key }: UseSupabaseSubscriptionProps) => {
+    isConnected: boolean;
+    isClientAvailable: boolean;
+};

package/dist/hooks/useSupabaseSubscription/useSupabaseSubscription.js

@@ -0,0 +1,37 @@
+'use client';
+import { useEffect, useRef } from 'react';
+import { supabaseClient } from '../../utils/supabase';
+export const useSupabaseSubscription = ({ config, callback, enabled = true, key }) => {
+    const subscriptionRef = useRef(null);
+    const callbackRef = useRef(callback);
+    callbackRef.current = callback;
+    useEffect(() => {
+        if (!enabled || !supabaseClient) {
+            return;
+        }
+        if (subscriptionRef.current) {
+            supabaseClient.removeChannel(subscriptionRef.current);
+            subscriptionRef.current = null;
+        }
+        const subscription = supabaseClient
+            .channel(key || config.channelName)
+            .on('postgres_changes', {
+            event: config.event || '*',
+            schema: config.schema || 'public',
+            table: config.table,
+            ...(config.filter && { filter: config.filter }),
+        }, (payload) => callbackRef.current(payload))
+            .subscribe();
+        subscriptionRef.current = subscription;
+        return () => {
+            if (subscriptionRef.current && supabaseClient) {
+                supabaseClient.removeChannel(subscriptionRef.current);
+                subscriptionRef.current = null;
+            }
+        };
+    }, [enabled, config.channelName, config.table, config.schema, config.event, config.filter, supabaseClient, key]);
+    return {
+        isConnected: !!subscriptionRef.current,
+        isClientAvailable: !!supabaseClient,
+    };
+};

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { squarefi_bff_api_client } from './api';
+export * from './utils/apiClientFactory';
+export * from './utils/tokensFactory';
+export * from './utils/fileStorage';
+export * from './constants';
+export * from './hooks';
+export * from './api/types/types';

package/dist/utils/apiClientFactory.d.ts

@@ -0,0 +1,31 @@
+import { AxiosRequestConfig } from 'axios';
+type CreateApiClientOptions = {
+    baseURL: string;
+    tenantId: string;
+    isBearerToken?: boolean;
+};
+export declare const createApiClient: ({ baseURL, isBearerToken, tenantId }: CreateApiClientOptions) => {
+    patchRequest: <T>(url: string, config?: AxiosRequestConfig) => Promise<T>;
+    postRequest: <T>(url: string, config?: AxiosRequestConfig) => Promise<T>;
+    deleteRequest: (url: string, config?: AxiosRequestConfig) => Promise<any>;
+    getRequest: <T>(url: string, config?: AxiosRequestConfig) => Promise<T>;
+};
+export declare const apiClientV1: {
+    patchRequest: <T>(url: string, config?: AxiosRequestConfig) => Promise<T>;
+    postRequest: <T>(url: string, config?: AxiosRequestConfig) => Promise<T>;
+    deleteRequest: (url: string, config?: AxiosRequestConfig) => Promise<any>;
+    getRequest: <T>(url: string, config?: AxiosRequestConfig) => Promise<T>;
+};
+export declare const apiClientV2: {
+    patchRequest: <T>(url: string, config?: AxiosRequestConfig) => Promise<T>;
+    postRequest: <T>(url: string, config?: AxiosRequestConfig) => Promise<T>;
+    deleteRequest: (url: string, config?: AxiosRequestConfig) => Promise<any>;
+    getRequest: <T>(url: string, config?: AxiosRequestConfig) => Promise<T>;
+};
+export declare const apiClientTOTP: {
+    patchRequest: <T>(url: string, config?: AxiosRequestConfig) => Promise<T>;
+    postRequest: <T>(url: string, config?: AxiosRequestConfig) => Promise<T>;
+    deleteRequest: (url: string, config?: AxiosRequestConfig) => Promise<any>;
+    getRequest: <T>(url: string, config?: AxiosRequestConfig) => Promise<T>;
+};
+export {};

package/dist/utils/apiClientFactory.js

@@ -0,0 +1,138 @@
+/* eslint-disable no-console */
+import { isTMA } from '@telegram-apps/sdk-react';
+import axios from 'axios';
+import { telegramSignUpPath, telegramSignInPath, refreshTokenPath } from '../api/auth';
+import { AppEnviroment, ResponseStatus } from '../constants';
+import { deleteTokens, getTokens, refreshTokens } from './tokensFactory';
+// eslint-disable-next-line no-constant-condition
+const apiV1BaseURL = process.env.API_URL ?? 'ENV variable API_URL is not defined';
+const apiV2BaseURL = process.env.API_V2_URL ?? 'ENV variable API_V2_URL is not defined';
+const apiTOTPBaseURL = process.env.API_TOTP_URL ?? 'ENV variable API_TOTP_URL is not defined';
+const envTenantId = process.env.TENANT_ID ?? 'ENV variable TENANT_ID is not defined';
+const envLogoutURL = process.env.LOGOUT_URL ?? '/auth/logout';
+let isTokenRefreshing = false;
+let requestQueue = [];
+export const createApiClient = ({ baseURL, isBearerToken, tenantId }) => {
+    const instance = axios.create({
+        baseURL,
+        timeout: 60000,
+    });
+    instance.interceptors.request.use((config) => {
+        const { access_token } = getTokens();
+        const modifiedHeaders = {
+            ...config.headers,
+            'x-tenant-id': tenantId,
+        };
+        if (access_token) {
+            const authHeader = isBearerToken ? `Bearer ${access_token}` : access_token;
+            modifiedHeaders.Authorization = authHeader;
+        }
+        config.context = {
+            ...config.context,
+            appEnvironment: isTMA() ? AppEnviroment.TELEGRAM : AppEnviroment.WEB,
+        };
+        return {
+            ...config,
+            headers: modifiedHeaders,
+        };
+    });
+    instance.interceptors.response.use((response) => response, (error) => {
+        if (typeof window === 'undefined') {
+            return Promise.reject(error);
+        }
+        if (error?.response?.status === ResponseStatus.UNAUTHORIZED &&
+            !error?.response?.config.context?.bypassUnauthorizedHandler) {
+            const { response, config: failedRequestConfig } = error;
+            const { refresh_token } = getTokens();
+            const isRetryRequest = failedRequestConfig.context?.isRetryRequest;
+            const isRefreshTokenRequest = failedRequestConfig.url?.includes(refreshTokenPath);
+            const isTelegramSignInRequest = failedRequestConfig.url?.includes(telegramSignInPath);
+            const isTelegramSignUpRequest = failedRequestConfig.url?.includes(telegramSignUpPath);
+            const isRefreshNotRequired = !refresh_token && !isTMA();
+            const isLogoutNeccesary = isRefreshNotRequired ||
+                isTelegramSignInRequest ||
+                isTelegramSignUpRequest ||
+                isRefreshTokenRequest ||
+                isRetryRequest;
+            const isRefreshAvailable = !isTokenRefreshing && !isRefreshNotRequired;
+            if (isLogoutNeccesary) {
+                if (typeof window !== 'undefined') {
+                    window.location.href = envLogoutURL;
+                    deleteTokens();
+                }
+                requestQueue = [];
+                return Promise.reject(response);
+            }
+            if (isRefreshAvailable) {
+                isTokenRefreshing = true;
+                refreshTokens()
+                    .then((data) => {
+                    if (data?.access_token) {
+                        requestQueue.forEach((request) => request.resolve());
+                        requestQueue = [];
+                    }
+                })
+                    .catch((tokenRefreshError) => {
+                    if (typeof window !== 'undefined') {
+                        window.location.href = envLogoutURL;
+                        deleteTokens();
+                    }
+                    requestQueue = [];
+                    return Promise.reject(tokenRefreshError);
+                })
+                    .finally(() => {
+                    isTokenRefreshing = false;
+                });
+            }
+            return new Promise((res, rej) => {
+                requestQueue.push({
+                    resolve: () => {
+                        failedRequestConfig.context = {
+                            ...failedRequestConfig.context,
+                            isRetryRequest: true,
+                        };
+                        return res(instance(failedRequestConfig));
+                    },
+                    reject: () => rej(instance(failedRequestConfig)),
+                });
+            });
+        }
+        console.error('Axios error', error);
+        return Promise.reject(error);
+    });
+    const patchRequest = async (url, config) => {
+        const { data = {}, ...restConfig } = config ?? {};
+        const res = await instance.patch(url, data, restConfig);
+        return res.data;
+    };
+    const postRequest = async (url, config) => {
+        const { data = {}, ...restConfig } = config ?? {};
+        const res = await instance.post(url, data, restConfig);
+        return res.data;
+    };
+    const deleteRequest = async (url, config) => {
+        const { data = {}, ...restConfig } = config ?? {};
+        const res = await instance.delete(url, { data, ...restConfig });
+        return res.data;
+    };
+    const getRequest = async (url, config) => {
+        const { params = {}, ...restConfig } = config ?? {};
+        const res = await instance.get(url, { params, ...restConfig });
+        return res.data;
+    };
+    return { patchRequest, postRequest, deleteRequest, getRequest };
+};
+export const apiClientV1 = createApiClient({
+    baseURL: apiV1BaseURL,
+    tenantId: envTenantId,
+});
+export const apiClientV2 = createApiClient({
+    baseURL: apiV2BaseURL,
+    isBearerToken: true,
+    tenantId: envTenantId,
+});
+export const apiClientTOTP = createApiClient({
+    baseURL: apiTOTPBaseURL,
+    isBearerToken: true,
+    tenantId: envTenantId,
+});

package/dist/utils/converters.d.ts

@@ -0,0 +1 @@
+export declare const convertPhoneToSupabaseFormat: (phone: string) => string;

package/dist/utils/converters.js

@@ -0,0 +1 @@
+export const convertPhoneToSupabaseFormat = (phone) => phone.replace(/\D/g, '');

package/dist/utils/encrypt.d.ts

@@ -0,0 +1,10 @@
+import { CipherKey } from 'crypto';
+import { API } from '../api/types/types';
+type MakeSecureRequestParams = {
+    callback: (props: API.Common.Encrypted.Request) => Promise<API.Common.Encrypted.Response>;
+    publicKey: string;
+};
+export declare const generateSecretKey: () => Buffer<ArrayBufferLike>;
+export declare const decryptAESData: (encryptedData: string, iv: string, secretKey: CipherKey) => Promise<any>;
+export declare const makeSecureRequest: <T>({ callback, publicKey }: MakeSecureRequestParams) => Promise<T>;
+export {};

package/dist/utils/encrypt.js

@@ -0,0 +1,77 @@
+import crypto from 'crypto';
+import NodeRSA from 'node-rsa';
+export const generateSecretKey = () => {
+    const secretKey = crypto.randomBytes(32);
+    return secretKey;
+};
+export const decryptAESData = async (encryptedData, iv, secretKey) => {
+    const decipher = crypto.createDecipheriv('aes-256-cbc', secretKey, Buffer.from(iv, 'base64'));
+    let decrypted = decipher.update(encryptedData, 'base64', 'utf8');
+    decrypted += decipher.final('utf8');
+    return JSON.parse(decrypted);
+};
+/**
+ * Очищает и валидирует публичный RSA ключ
+ * Исправляет ошибку InvalidAsn1Error: encoding too long
+ * путем удаления лишних символов и нормализации переносов строк
+ */
+const cleanAndValidatePublicKey = (publicKey) => {
+    try {
+        // Декодируем base64 ключ
+        const publicKeyBase64 = Buffer.from(publicKey, 'base64').toString('utf8');
+        // Удаляем лишние символы (переносы строк, пробелы в начале и конце)
+        // Нормализуем переносы строк для корректной обработки ASN.1
+        const cleanedKey = publicKeyBase64.trim().replace(/\r?\n|\r/g, '\n');
+        // Проверяем, что ключ содержит необходимые маркеры
+        if (!cleanedKey.includes('BEGIN') || !cleanedKey.includes('END')) {
+            throw new Error('Invalid public key format: missing BEGIN/END markers');
+        }
+        return cleanedKey;
+    }
+    catch (error) {
+        throw new Error(`Invalid public key format: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+};
+/**
+ * Автоматически определяет формат RSA ключа по заголовку
+ * Помогает избежать ошибок импорта при неправильном указании формата
+ */
+const detectKeyFormat = (key) => {
+    if (key.includes('BEGIN RSA PUBLIC KEY')) {
+        return 'pkcs1';
+    }
+    else if (key.includes('BEGIN PUBLIC KEY')) {
+        return 'pkcs8';
+    }
+    // По умолчанию возвращаем pkcs8, как было ранее
+    return 'pkcs8';
+};
+export const makeSecureRequest = async ({ callback, publicKey }) => {
+    const clientRsa = new NodeRSA();
+    try {
+        // Очищаем и валидируем публичный ключ
+        const cleanedPublicKey = cleanAndValidatePublicKey(publicKey);
+        // Определяем формат ключа автоматически
+        const keyFormat = detectKeyFormat(cleanedPublicKey);
+        // Импортируем ключ с правильным форматом
+        clientRsa.importKey(cleanedPublicKey, `${keyFormat}-public-pem`);
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        throw new Error(`Failed to import RSA public key: ${errorMessage}`);
+    }
+    const clientSecretKey = generateSecretKey();
+    const clientPayload = {
+        key: clientSecretKey.toString('base64'),
+        timestamp: Date.now(),
+    };
+    const encrypted_key = clientRsa.encrypt(JSON.stringify(clientPayload), 'base64');
+    const { success, encrypted, data, iv } = await callback({ encrypted_key });
+    if (success && encrypted && data && iv) {
+        const decryptedData = await decryptAESData(data, iv, clientSecretKey);
+        return decryptedData.data;
+    }
+    else {
+        throw new Error('Failed to get encrypted secret key');
+    }
+};

package/dist/utils/fileStorage.d.ts

@@ -0,0 +1,120 @@
+/**
+ * Типы для работы с файловым хранилищем
+ */
+export interface UploadFileOptions {
+    file: File | Blob;
+    fileName: string;
+    bucket: string;
+    folder?: string;
+    contentType?: string;
+    cacheControl?: string;
+    upsert?: boolean;
+    authToken?: string;
+}
+export interface UploadFileResult {
+    success: boolean;
+    publicUrl?: string;
+    signedUrl?: string;
+    path?: string;
+    error?: string;
+}
+export interface GetFileUrlOptions {
+    path: string;
+    bucket: string;
+    expiresIn?: number;
+    authToken?: string;
+}
+/**
+ * Названия бакетов по умолчанию
+ */
+export declare const ORDER_DOCS_BUCKET = "order_docs";
+/**
+ * Загружает файл в Supabase Storage
+ * Файл сохраняется по пути: {folder}/{fileName} или {fileName}
+ *
+ * Папки создаются автоматически при загрузке файла, если их не существует.
+ * Можно указывать вложенные папки через слэш: 'images/avatars/2024'
+ *
+ * @param options - параметры загрузки файла
+ * @param options.folder - опциональная папка внутри бакета (например, 'documents', 'images/avatars')
+ * @returns результат загрузки с ссылкой на файл
+ */
+export declare const uploadFile: (options: UploadFileOptions) => Promise<UploadFileResult>;
+/**
+ * Получает подписанный URL для доступа к файлу
+ *
+ * @param options - параметры получения URL
+ * @returns подписанный URL или null при ошибке
+ */
+export declare const getSignedUrl: (options: GetFileUrlOptions) => Promise<string | null>;
+/**
+ * Получает публичный URL для файла
+ *
+ * Для ПРИВАТНЫХ бакетов:
+ * - URL постоянный (не истекает)
+ * - Требует Authorization header с service role key для доступа
+ * - Используется на backend для суперадмина
+ *
+ * Для ПУБЛИЧНЫХ бакетов:
+ * - URL доступен всем без аутентификации
+ *
+ * @example Backend usage for private buckets:
+ * ```typescript
+ * const url = getPublicUrl(filePath, bucket);
+ *
+ * // Access with service role key:
+ * fetch(url, {
+ *   headers: {
+ *     'Authorization': `Bearer ${SUPABASE_SERVICE_ROLE_KEY}`
+ *   }
+ * })
+ * ```
+ *
+ * @param path - путь к файлу
+ * @param bucket - название бакета
+ * @returns постоянный URL
+ */
+export declare const getPublicUrl: (path: string, bucket: string) => string | null;
+/**
+ * Удаляет файл из хранилища
+ *
+ * @param path - путь к файлу
+ * @param bucket - название бакета
+ * @param authToken - JWT token для авторизации
+ * @returns true при успешном удалении
+ */
+export declare const deleteFile: (path: string, bucket: string, authToken?: string) => Promise<boolean>;
+/**
+ * Удаляет несколько файлов из хранилища
+ *
+ * @param paths - массив путей к файлам
+ * @param bucket - название бакета
+ * @param authToken - JWT token для авторизации
+ * @returns true при успешном удалении всех файлов
+ */
+export declare const deleteFiles: (paths: string[], bucket: string, authToken?: string) => Promise<boolean>;
+/**
+ * Получает список файлов пользователя
+ *
+ * @param userId - ID пользователя
+ * @param bucket - название бакета
+ * @param authToken - JWT token для авторизации
+ * @returns список файлов или пустой массив при ошибке
+ */
+export declare const listUserFiles: (userId: string, bucket: string, authToken?: string) => Promise<Array<{
+    name: string;
+    id?: string;
+    updated_at?: string;
+    created_at?: string;
+    last_accessed_at?: string;
+    metadata?: Record<string, unknown>;
+}>>;
+/**
+ * Скачивает файл из хранилища
+ *
+ * @param path - путь к файлу
+ * @param bucket - название бакета
+ * @param authToken - JWT token для авторизации
+ * @returns Blob файла или null при ошибке
+ */
+export declare const downloadFile: (path: string, bucket: string, authToken?: string) => Promise<Blob | null>;