squarefi-bff-api-module 1.32.1 → 1.32.2

package/src/hooks/useFileUpload.ts

@@ -1,129 +0,0 @@
-import { useState, useCallback } from 'react';
-import { uploadFile, UploadFileOptions, UploadFileResult } from '../utils/fileStorage';
-
-interface UseFileUploadOptions {
-  bucket: string;
-  folder?: string; // Папка внутри бакета (например, 'documents', 'images/avatars'). Создается автоматически, если не существует
-  authToken?: string; // JWT token для авторизации
-  onSuccess?: (result: UploadFileResult) => void;
-  onError?: (error: string) => void;
-}
-
-interface UseFileUploadReturn {
-  upload: (file: File, fileName?: string) => Promise<UploadFileResult>;
-  uploading: boolean;
-  progress: number;
-  error: string | null;
-  result: UploadFileResult | null;
-  reset: () => void;
-}
-
-/**
- * React хук для загрузки файлов в Supabase Storage
- *
- * Папки создаются автоматически при загрузке файла, если их не существует.
- *
- * @example
- * ```tsx
- * // Загрузка в корень бакета
- * const { upload, uploading, error, result } = useFileUpload({
- *   bucket: 'user-files',
- *   onSuccess: (result) => console.log('Загружено:', result.path),
- * });
- *
- * // Загрузка в конкретную папку (папка создастся автоматически)
- * const { upload } = useFileUpload({
- *   bucket: 'documents',
- *   folder: 'invoices', // файл будет загружен в invoices/
- * });
- *
- * // Загрузка во вложенную папку (все папки создадутся автоматически)
- * const { upload } = useFileUpload({
- *   bucket: 'images',
- *   folder: 'avatars/2024', // файл будет загружен в avatars/2024/
- * });
- *
- * const handleFileChange = async (e: React.ChangeEvent<HTMLInputElement>) => {
- *   const file = e.target.files?.[0];
- *   if (file) await upload(file);
- * };
- * ```
- */
-export const useFileUpload = (options: UseFileUploadOptions): UseFileUploadReturn => {
-  const { bucket, folder, authToken, onSuccess, onError } = options;
-
-  const [uploading, setUploading] = useState(false);
-  const [progress, setProgress] = useState(0);
-  const [error, setError] = useState<string | null>(null);
-  const [result, setResult] = useState<UploadFileResult | null>(null);
-
-  const upload = useCallback(
-    async (file: File, customFileName?: string): Promise<UploadFileResult> => {
-      setUploading(true);
-      setProgress(0);
-      setError(null);
-      setResult(null);
-
-      try {
-        // Симулируем прогресс (Supabase не предоставляет реальный progress)
-        const progressInterval = setInterval(() => {
-          setProgress((prev) => Math.min(prev + 10, 90));
-        }, 100);
-
-        const uploadOptions: UploadFileOptions = {
-          file,
-          fileName: customFileName || `${Date.now()}-${file.name}`,
-          bucket,
-          folder,
-          contentType: file.type,
-          authToken,
-        };
-
-        const uploadResult = await uploadFile(uploadOptions);
-
-        clearInterval(progressInterval);
-        setProgress(100);
-        setResult(uploadResult);
-
-        if (uploadResult.success) {
-          onSuccess?.(uploadResult);
-        } else {
-          const errorMsg = uploadResult.error || 'Ошибка загрузки файла';
-          setError(errorMsg);
-          onError?.(errorMsg);
-        }
-
-        return uploadResult;
-      } catch (err) {
-        const errorMsg = err instanceof Error ? err.message : 'Непредвиденная ошибка';
-        setError(errorMsg);
-        onError?.(errorMsg);
-        setProgress(0);
-
-        return {
-          success: false,
-          error: errorMsg,
-        };
-      } finally {
-        setUploading(false);
-      }
-    },
-    [bucket, folder, authToken, onSuccess, onError],
-  );
-
-  const reset = useCallback(() => {
-    setUploading(false);
-    setProgress(0);
-    setError(null);
-    setResult(null);
-  }, []);
-
-  return {
-    upload,
-    uploading,
-    progress,
-    error,
-    result,
-    reset,
-  };
-};

package/src/hooks/useSupabaseSubscription/config.ts

@@ -1,7 +0,0 @@
-import { SubscriptionConfig } from './types';
-
-export const createWalletTransactionsConfig = (walletId: string): SubscriptionConfig => ({
-  channelName: `wallet-transactions-${walletId}`,
-  table: 'transactions',
-  filter: `wallet_id=eq.${walletId}`,
-});

package/src/hooks/useSupabaseSubscription/types.ts

@@ -1,18 +0,0 @@
-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/src/hooks/useSupabaseSubscription/useSupabaseSubscription.ts

@@ -1,53 +0,0 @@
-'use client';
-
-import { useEffect, useRef } from 'react';
-
-import { UseSupabaseSubscriptionProps } from './types';
-
-import { supabaseClient } from '../../utils/supabase';
-
-export const useSupabaseSubscription = ({ config, callback, enabled = true, key }: UseSupabaseSubscriptionProps) => {
-  const subscriptionRef = useRef<any>(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' as any,
-        {
-          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/src/utils/apiClientFactory.ts

@@ -1,194 +0,0 @@
-/* eslint-disable no-console */
-import { isTMA } from '@telegram-apps/sdk-react';
-import axios, { AxiosRequestConfig, AxiosResponse, InternalAxiosRequestConfig } 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';
-
-type AxiosError = {
-  response: AxiosResponse;
-  config: InternalAxiosRequestConfig;
-};
-
-type CreateApiClientOptions = {
-  baseURL: string;
-  tenantId: string;
-  isBearerToken?: boolean;
-};
-
-type RequestQueueItem = {
-  resolve: Function;
-  reject: Function;
-};
-
-let isTokenRefreshing = false;
-let requestQueue: RequestQueueItem[] = [];
-
-export const createApiClient = ({ baseURL, isBearerToken, tenantId }: CreateApiClientOptions) => {
-  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,
-    } as unknown as InternalAxiosRequestConfig;
-  });
-
-  instance.interceptors.response.use(
-    (response) => response,
-    (error: AxiosError) => {
-      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 <T>(url: string, config?: AxiosRequestConfig): Promise<T> => {
-    const { data = {}, ...restConfig } = config ?? {};
-
-    const res = await instance.patch(url, data, restConfig);
-
-    return res.data;
-  };
-
-  const postRequest = async <T>(url: string, config?: AxiosRequestConfig): Promise<T> => {
-    const { data = {}, ...restConfig } = config ?? {};
-
-    const res = await instance.post(url, data, restConfig);
-
-    return res.data;
-  };
-
-  const deleteRequest = async (url: string, config?: AxiosRequestConfig) => {
-    const { data = {}, ...restConfig } = config ?? {};
-
-    const res = await instance.delete(url, { data, ...restConfig });
-
-    return res.data;
-  };
-
-  const getRequest = async <T>(url: string, config?: AxiosRequestConfig): Promise<T> => {
-    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/src/utils/converters.ts

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

package/src/utils/encrypt.ts

@@ -1,96 +0,0 @@
-import crypto, { CipherKey } from 'crypto';
-import NodeRSA from 'node-rsa';
-
-import { API } from '../api/types/types';
-
-type MakeSecureRequestParams = {
-  callback: (props: API.Common.Encrypted.Request) => Promise<API.Common.Encrypted.Response>;
-  publicKey: string;
-};
-
-export const generateSecretKey = () => {
-  const secretKey = crypto.randomBytes(32);
-  return secretKey;
-};
-
-export const decryptAESData = async (encryptedData: string, iv: string, secretKey: CipherKey) => {
-  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: string): string => {
-  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: string): 'pkcs1' | 'pkcs8' => {
-  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 <T>({ callback, publicKey }: MakeSecureRequestParams): Promise<T> => {
-  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');
-  }
-};