api.ts

import filesizeParser from 'filesize-parser';
import FormData from 'form-data';
import fs from 'fs';
import fetch from 'node-fetch';
import path from 'path';
import ProgressBar from 'progress';
import { getBaseUrl } from 'utils/http-helper';
import packageJson from '../package.json';
import type { Package, Session } from './types';
import { credentialFile, IS_CRESC, pricingPageUrl } from './utils/constants';
import { t } from './utils/i18n';
import {
  measureTcpLatency,
  type RuntimeRequestInit,
  type RuntimeResponse,
  runtimeFetch,
} from './utils/runtime';

let session: Session | undefined;
let savedSession: Session | undefined;
let apiToken: string | undefined;

const userAgent = `react-native-update-cli/${packageJson.version}`;

export const getSession = () => session;

export const getApiToken = () => apiToken;

export const setApiToken = (token: string) => {
  apiToken = token;
};

const loadApiTokenFromEnv = () => {
  // Use CRESC_API_TOKEN for cresc, PUSHY_API_TOKEN for pushy
  const envToken = IS_CRESC
    ? process.env.CRESC_API_TOKEN
    : process.env.PUSHY_API_TOKEN;
  if (envToken) {
    apiToken = envToken;
  }
};

export const replaceSession = (newSession: { token: string }) => {
  session = newSession;
};

export const loadSession = async () => {
  loadApiTokenFromEnv();
  if (fs.existsSync(credentialFile)) {
    try {
      replaceSession(JSON.parse(fs.readFileSync(credentialFile, 'utf8')));
      savedSession = session;
    } catch (e) {
      console.error(
        `Failed to parse file ${credentialFile}. Try to remove it manually.`,
      );
      throw e;
    }
  }
};

export const saveSession = () => {
  // Only save on change.
  if (session !== savedSession) {
    const current = session;
    const data = JSON.stringify(current, null, 4);
    fs.writeFileSync(credentialFile, data, 'utf8');
    savedSession = current;
  }
};

export const closeSession = () => {
  if (fs.existsSync(credentialFile)) {
    fs.unlinkSync(credentialFile);
    savedSession = undefined;
  }
  session = undefined;
};

function createRequestError(
  error: unknown,
  requestUrl: string,
  status?: number,
) {
  const message =
    typeof error === 'string'
      ? error
      : error instanceof Error
        ? error.message
        : String(error);
  const requestError = new Error(`${message}\nURL: ${requestUrl}`) as Error & {
    status?: number;
  };
  requestError.status = status;
  return requestError;
}

const PROXY_ERROR_PATTERNS = [
  'socket disconnected before secure TLS connection',
  'ECONNRESET',
  'ECONNREFUSED',
  'DEPTH_ZERO_SELF_SIGNED_CERT',
  'UNABLE_TO_VERIFY_LEAF_SIGNATURE',
  'CERT_HAS_EXPIRED',
  'self signed certificate',
  'proxy',
  'ETIMEDOUT',
  'EHOSTUNREACH',
  'ENETUNREACH',
];

function isProxyRelatedError(error: unknown): boolean {
  const msg =
    error instanceof Error
      ? error.message
      : typeof error === 'string'
        ? error
        : '';
  const lower = msg.toLowerCase();
  return PROXY_ERROR_PATTERNS.some((p) => lower.includes(p.toLowerCase()));
}

async function query(url: string, options: RuntimeRequestInit) {
  const baseUrl = await getBaseUrl;
  const fullUrl = `${baseUrl}${url}`;
  let resp: RuntimeResponse;
  try {
    resp = await runtimeFetch(fullUrl, options);
  } catch (error) {
    const baseError = createRequestError(error, fullUrl);
    if (isProxyRelatedError(error)) {
      throw new Error(
        `${baseError.message}\n\n${t('proxyNetworkError')}\n${t('proxyNetworkErrorTips')}`,
      );
    }
    throw baseError;
  }
  const text = await resp.text();
  let json: any;
  try {
    json = JSON.parse(text);
  } catch (_e) {
    if (resp.status === 200 && text) {
      console.warn(
        `Warning: API returned 200 with non-JSON body (${text.length} bytes)`,
      );
    }
  }

  if (resp.status !== 200) {
    const message = json?.message || resp.statusText || `HTTP ${resp.status}`;
    if (resp.status === 401) {
      throw createRequestError(t('loginExpired'), fullUrl, resp.status);
    }
    throw createRequestError(message, fullUrl, resp.status);
  }
  return json;
}

function queryWithoutBody(method: string) {
  return (api: string) => {
    const headers: Record<string, string> = {
      'User-Agent': userAgent,
    };
    if (apiToken) {
      headers['x-api-token'] = apiToken;
    } else if (session?.token) {
      headers['X-AccessToken'] = session.token;
    }
    return query(api, {
      method,
      headers,
    });
  };
}

function queryWithBody(method: string) {
  return (api: string, body?: Record<string, any>) => {
    const headers: Record<string, string> = {
      'User-Agent': userAgent,
      'Content-Type': 'application/json',
    };
    if (apiToken) {
      headers['x-api-token'] = apiToken;
    } else if (session?.token) {
      headers['X-AccessToken'] = session.token;
    }
    return query(api, {
      method,
      headers,
      body: JSON.stringify(body),
    });
  };
}

export const get = queryWithoutBody('GET');
export const post = queryWithBody('POST');
export const put = queryWithBody('PUT');
export const doDelete = queryWithBody('DELETE');

export async function uploadFile(fn: string, key?: string) {
  const { url, backupUrl, formData, maxSize } = await post('/upload', {
    ext: path.extname(fn),
  });
  let realUrl = url;
  if (backupUrl) {
    if (global.USE_ACC_OSS) {
      realUrl = backupUrl;
    } else {
      const latency = await measureTcpLatency(url, {
        attempts: 4,
        timeout: 1000,
      });
      if (!Number.isFinite(latency) || latency > 150) {
        realUrl = backupUrl;
      }
    }
    // console.log({realUrl});
  }

  const fileSize = fs.statSync(fn).size;
  if (maxSize && fileSize > filesizeParser(maxSize)) {
    const readableFileSize = `${(fileSize / 1048576).toFixed(1)}m`;
    throw new Error(
      t('fileSizeExceeded', {
        fileSize: readableFileSize,
        maxSize,
        pricingPageUrl,
      }),
    );
  }

  const bar = new ProgressBar('  Uploading [:bar] :percent :etas', {
    complete: '=',
    incomplete: ' ',
    total: fileSize,
  });

  const form = new FormData();

  for (const [k, v] of Object.entries(formData)) {
    form.append(k, v);
  }
  const fileStream = fs.createReadStream(fn);
  fileStream.on('data', (data) => {
    bar.tick(data.length);
  });

  if (key) {
    form.append('key', key);
  }
  form.append('file', fileStream);
  // form.append('file', fileStream, {
  //   contentType: 'application/octet-stream',
  // });

  let res: fetch.Response;
  try {
    res = await fetch(realUrl, {
      method: 'POST',
      body: form,
    });
  } catch (error) {
    if (isProxyRelatedError(error)) {
      const rawMessage =
        error instanceof Error ? error.message : String(error);
      throw new Error(
        `${rawMessage}\n\n${t('proxyNetworkError')}\n${t('proxyNetworkErrorTips')}`,
      );
    }
    throw createRequestError(error, realUrl);
  }

  if (res.status > 299) {
    throw createRequestError(
      `${res.status}: ${res.statusText || 'Upload failed'}`,
      realUrl,
    );
  }

  // const body = await response.json();
  return { hash: key || formData.key };
}

export const getAllPackages = async (appId: string) => {
  const { data } = await get(`/app/${appId}/package/list?limit=1000`);
  return data as Package[] | undefined | null;
};