myprojplanet_vite/src/store/Api/Instance.ts

import type { AxiosRequestConfig, AxiosInstance, AxiosResponse } from 'axios';
import axios from 'axios'

// import LoginModule from '../Modules/Auth/LoginStore'
import { toolsext } from '@src/store/Modules/toolsext'
import { serv_constants } from '@src/store/Modules/serv_constants'
import { useGlobalStore } from '@store/globalStore'
import { useUserStore } from '@store/UserStore'
import { tools } from '@src/store/Modules/tools'
import * as Types from './ApiTypes'

import type { Observable } from 'rxjs';
import { from } from 'rxjs';
import { mergeMap, toArray } from 'rxjs/operators';

export let API_URL = ''
export const axiosInstance: AxiosInstance = axios.create({
  baseURL: API_URL,
  headers: {
    Accept: 'application/json',
  },
})


axiosInstance.interceptors.response.use(

  (response) => {
    if (import.meta.env.VITE_DEBUG === '1') console.log(response)
    return response
  },
  (error) => {
    const globalStore = useGlobalStore()
    // console.log('error', error)
    if (error.response) {
      if (import.meta.env.VITE_DEBUG === '1') console.log('Status = ', error.response.status)
      console.log('Request Error: ', error.response)
      if (error.response.status !== 0) {
        globalStore.setStateConnection('online')
      } else {
        globalStore.setStateConnection('offline')
      }
    } else {
      globalStore.setStateConnection('offline')
    }
    return Promise.reject(error)
  },
)

export const addAuthHeaders = () => {
  // axiosInstance.defaults.headers.Authorization = `Bearer ${LoginModule.userInfos.userToken}`
}

//export const removeAuthHeaders = () => {
//  delete axiosInstance.defaults.headers.Authorization
//}

async function generateStream(path: string, payload: any, config?: RequestInit, options?: any): Promise<AsyncIterable<any>> {
  const userStore = useUserStore()

  const mieiparam: any = {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'x-auth': userStore.x_auth_token,
      'x-refrtok': userStore.refreshToken,
    },
    body: JSON.stringify(payload),
    signal: options?.signal,
    ...config
  }

  console.log('marams: ', mieiparam)

  const response = await fetch(
    path,
    mieiparam,
  );
  console.log('USCITA DA FETCH... !!!!!')
  if (response.status !== 200) throw new Error(response.status.toString());
  return getIterableStream(response);
}

function getIterableStream(stream: NodeJS.ReadableStream): AsyncIterable<any> {
  return {
    [Symbol.asyncIterator](): AsyncIterator<any> {
      let buffer = '';
      return {
        async next(): Promise<IteratorResult<any>> {
          while (true) {
            const chunk = await new Promise<string>((resolve, reject) => {
              stream.once('data', (data: Buffer) => resolve(data.toString()));
              stream.once('error', (err) => reject(err));
              stream.once('end', () => resolve(''));
            });
            buffer += chunk;
            if (buffer.includes('\n\n')) {
              const event = buffer.slice(0, buffer.indexOf('\n\n'));
              buffer = buffer.slice(buffer.indexOf('\n\n') + 2);
              try {
                return { value: JSON.parse(event.slice('data: '.length)), done: false };
              } catch (error) {
                console.error('Error parsing event data:', error);
              }
            } else if (chunk === '') {
              return { value: undefined, done: true };
            }
          }
        },
      };
    },
  };
}

async function Request(type: string, path: string, payload: any, responsedata?: any, options?: any): Promise<Types.AxiosSuccess | Types.AxiosError | undefined> {

  let ricevuto = false
  const userStore = useUserStore()
  const globalStore = useGlobalStore()


  try {
    if (tools.isDebug()) console.log('Axios Request', path, type, tools.notshowPwd(payload))
    let response: AxiosResponse
    const config: AxiosRequestConfig = {
      baseURL: globalStore.getServerHost(),
      headers: {
        'Content-Type': 'application/json',
        'x-auth': userStore.x_auth_token,
        'x-refrtok': userStore.refreshToken,
      },
      ...responsedata,
    }

    if (options?.stream) {
      config.responseType = 'stream';
    }

    if (type === 'post' || type === 'put' || type === 'patch') {

      if (options?.stream) {
        console.log('GENERATESTREAM...')
        const stream = await generateStream(path, payload, config, options);
        console.log('USCITOOOOOOOOOOOOOOOOOOOOO ------------------------')

        return new Promise((resolve, reject) => {
          const events$: Observable<any> = from(stream);
          events$
            .pipe(
              mergeMap((event) => from([event])),
              toArray()
            )
            .subscribe(
              (data) => {
                console.log('Received data:', data);
                // Elabora i dati ricevuti
                resolve({ data, status: response.status, statusText: response.statusText, headers: response.headers, config: response.config });
              },
              (error) => {
                console.error('Stream error:', error);
                reject(error);
              },
              () => {
                console.log('Stream completed');
              }
            );

        });
      } else {

        response = await axiosInstance[type](path, payload, config)

        ricevuto = true
        // console.log('Request Response: ', response)
        // console.log(new Types.AxiosSuccess(response.data, response.status))

        const setAuthToken = (path === '/updatepwd') || (path === '/users/login')

        // console.log('--------- 0 ')

        if (response && (response.status === 200)) {
          let x_auth_token = ''
          let refreshToken = ''
          try {
            if (setAuthToken || (path === '/users/login')) {
              x_auth_token = String(response.headers['x-auth'])
              refreshToken = String(response.headers['x-refrtok'])

              if (x_auth_token === '') {
                userStore.setServerCode(toolsext.ERR_AUTHENTICATION)
              }
              if (setAuthToken) {
                userStore.UpdatePwd(x_auth_token, refreshToken)
                localStorage.setItem(toolsext.localStorage.token, x_auth_token)
                localStorage.setItem(toolsext.localStorage.refreshToken, refreshToken)
              }

              userStore.setAuth(x_auth_token, refreshToken)
              localStorage.setItem(toolsext.localStorage.token, x_auth_token)
              localStorage.setItem(toolsext.localStorage.refreshToken, refreshToken)
            }

            globalStore.setStateConnection(ricevuto ? 'online' : 'offline')
            userStore.setServerCode(tools.OK)
          } catch (e) {
            if (setAuthToken) {
              userStore.setServerCode(toolsext.ERR_AUTHENTICATION)
              userStore.setAuth('', '')
            }
            globalStore.setStateConnection(ricevuto ? 'online' : 'offline')
            return Promise.reject(new Types.AxiosError(serv_constants.RIS_CODE__HTTP_FORBIDDEN_INVALID_TOKEN, null, toolsext.ERR_AUTHENTICATION))
          }
        }

        return new Types.AxiosSuccess(response.data, response.status)
      }
    } else if (type === 'get' || type === 'delete') {
      // @ts-ignore
      response = await axiosInstance[type](path, {
        baseURL: globalStore.getServerHost(),
        params: payload,
        headers: {
          'Content-Type': 'application/json',
          'x-auth': userStore.x_auth_token,
          'x-refrtok': userStore.refreshToken,
        },
        ...responsedata,
      })
      ricevuto = true
      return new Types.AxiosSuccess(response.data, response.status)
    } else if (type === 'postFormData') {
      console.log('postFormData', payload)
      response = await axiosInstance.post(path, payload, {
        baseURL: globalStore.getServerHost(),
        headers: {
          'Content-Type': 'multipart/form-data',
          'x-auth': userStore.x_auth_token,
          'x-refrtok': userStore.refreshToken,
        },
        ...responsedata,
      })
      ricevuto = true
      return new Types.AxiosSuccess(response.data, response.status)
    }
  } catch (error: any) {
    setTimeout(() => {
      globalStore.connData.uploading_server = (globalStore.connData.uploading_server === 1) ? -1 : globalStore.connData.uploading_server
      globalStore.connData.downloading_server = (globalStore.connData.downloading_server === 1) ? -1 : globalStore.connData.downloading_server
    }, 1000)

    if (import.meta.env.DEV) {
      console.log('ERROR using', path)
      // console.log('Error received: ', error)
      // console.log('ricevuto=', ricevuto)
      console.log('error.response=', error.response)
    }
    let mycode = 0
    if (!ricevuto) {
      mycode = toolsext.ERR_SERVERFETCH
      userStore.setServerCode(toolsext.ERR_SERVERFETCH)
    } else {
      mycode = toolsext.ERR_GENERICO
      userStore.setServerCode(toolsext.ERR_GENERICO)
    }

    if (error.response) {
      let code = 0
      if (error.response.data && error.response.data.code) {
        code = error.response.data.code
        mycode = error.response.data.code
        userStore.setServerCode(mycode)
      }
      return Promise.reject(new Types.AxiosError(error.response.status, error.response.data, code))
    }
    return Promise.reject(new Types.AxiosError(0, null, mycode, error))
  }
}
export default Request