dpu-cloud-sdk 1.0.0

package/src/DPUClient.ts

@@ -0,0 +1,1505 @@
+import pLimit from "p-limit";
+import {
+  CancelDownload,
+  CompressFolder,
+  GetStatusCompress,
+} from "./api/compress";
+import {
+  BaseReponseModel,
+  CompressionResponse,
+  CompressStatus,
+  InitUploadResponse,
+  PresignURLResponse,
+  Token,
+  TranslateInfo,
+  TranslateStatusInfo,
+} from "./models/ResponseModel";
+import { ServiceIntegration } from "./ServiceIntegration";
+import { ApiStatus, ConfigFileRules } from "./utils/Constants";
+import { dpuConfig } from "./utils/Config";
+import { chunkArray, readFileDataAsBase64 } from "./utils/Helper";
+import { Scope, StatusWorker } from "./utils/Enum";
+// import streamSaver from "streamsaver";
+import {
+  GetEPSGRegionCode,
+  GetFileTileSet,
+  GetStatusTranslate,
+  GetStatusTranslateFile,
+  TranslateFile,
+} from "./api/translate";
+import {
+  GetStatusTranslateRequest,
+  TranslateRequest,
+} from "./models/RequestModel";
+import { GetToken } from "./api/auth";
+
+interface ISingleFileUpload {
+  currentPresignUrl: PresignURLResponse;
+  arrayBuffer: ArrayBuffer;
+  partNumber: number;
+  onProgress?: (chunkUploaded: number) => void;
+  requestId: string;
+  cancellationToken?: AbortController;
+  dataUploadId?: string;
+  fileName?: string;
+}
+
+interface IMultiFileUpload {
+  bucketName: string;
+  arrayBuffer: ArrayBuffer;
+  index: number;
+  percentOfChild?: ({
+    fileKey,
+    versionFile,
+  }: {
+    fileKey: string;
+    versionFile?: string;
+  }) => void;
+  requestId: string;
+  fullName: string;
+  accessToken: string;
+  fileKey: string;
+  reGetAccessToken?: () => string;
+  initUpload?: InitUploadResponse;
+  isGetInfo?: boolean;
+  cancellationToken?: AbortController;
+  preSignUrl?: PresignURLResponse;
+  dataUploadId?: string;
+}
+
+interface WorkerStatus {
+  worker: Worker;
+  taskNumber: number;
+  id: number;
+  taskHandle: number;
+}
+
+type FileUploadType = {
+  file: File;
+  fileKey: string;
+  customFileName?: string;
+  initUpload?: InitUploadResponse;
+  isGetInfo?: boolean;
+  preSignUrl?: PresignURLResponse;
+};
+
+export class DPUClient {
+  private accessToken?: string;
+  private reFreshToken?: () => Promise<string>;
+  private maxRetry: number;
+  private workersStatus: WorkerStatus[] = [];
+
+  constructor(
+    accessToken?: string,
+    reFreshToken?: () => Promise<string>,
+    maxRetry?: number | undefined,
+    baseURL?: string
+  ) {
+    this.accessToken = accessToken;
+    this.reFreshToken = reFreshToken;
+    this.maxRetry = maxRetry || ConfigFileRules.MaxRetry;
+    
+    // Set the base URL if provided
+    if (baseURL) {
+      dpuConfig.setBaseURL(baseURL);
+    }
+  }
+  private async baseAction<T>(
+    action: (accessToken: string) => Promise<BaseReponseModel<T>>
+  ): Promise<T> {
+    return new Promise(async (resolve, reject) => {
+      try {
+        if (this.accessToken) {
+          let currentRetry = 0;
+          let response: BaseReponseModel<T>;
+          do {
+            currentRetry++;
+            response = await action(this.accessToken);
+            if (response.statusCode === ApiStatus.Success)
+              resolve(response.data);
+            else if (
+              response.statusCode === ApiStatus.Unauthorized &&
+              this.reFreshToken
+            ) {
+              this.accessToken = await this.reFreshToken();
+            } else reject(response.message);
+          } while (
+            this.maxRetry > currentRetry &&
+            response.statusCode === ApiStatus.Unauthorized
+          );
+        } else reject("Access token is required");
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+
+  private async baseActionAnonymous<T>(
+    action: () => Promise<BaseReponseModel<T>>
+  ): Promise<T> {
+    return new Promise(async (resolve, reject) => {
+      try {
+        let response: BaseReponseModel<T>;
+        response = await action();
+        if (response.statusCode === ApiStatus.Success) resolve(response.data);
+        else reject(response.message);
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+
+  //#region Compress and Download Folder
+  public async compressFolder(
+    bucketName: string,
+    rootFolder?: string
+  ): Promise<CompressionResponse> {
+    return await this.baseAction<CompressionResponse>((accessToken: string) => {
+      return CompressFolder(accessToken, bucketName, rootFolder);
+    });
+  }
+
+  public async getStatusCompress(
+    requestIds: string[]
+  ): Promise<CompressStatus> {
+    return await this.baseAction<CompressStatus>((accessToken: string) => {
+      return GetStatusCompress(requestIds, accessToken);
+    });
+  }
+
+  public async cancelDownload(requestId: string): Promise<boolean> {
+    return await this.baseAction<boolean>((accessToken: string) => {
+      return CancelDownload(requestId, accessToken);
+    });
+  }
+  //#endregion
+  //#region Upload File
+  public async uploadFileAferInit(
+    path: string,
+    file: File,
+    initUpload?: InitUploadResponse,
+    cancellationToken?: AbortController,
+    onProgress?: (chunkUploaded: number) => void,
+    maxWebWorker?: number,
+    worker?: Worker,
+    dataUploadId?: string
+  ) {
+    const bucketName = path.split("/").at(0);
+    if (!bucketName)
+      return new Promise((resolve, reject) => {
+        reject("Path is not valid");
+      });
+    const customFileName = path.split("/").at(-1);
+    if (!customFileName)
+      return new Promise((resolve, reject) => {
+        reject("Path is not valid");
+      });
+    const prefix = path
+      .replace(bucketName + "/", "")
+      .replace(customFileName, "");
+    if (cancellationToken?.signal.aborted) {
+      return new Promise((resolve, reject) => {
+        reject("Upload cancelled");
+      });
+    }
+    const abortHandler = () => {
+      // Cleanup workers
+      this.workersStatus.forEach((workerStatus) => {
+        workerStatus.worker.terminate();
+      });
+      this.workersStatus = [];
+    };
+    cancellationToken?.signal.addEventListener("abort", abortHandler);
+    try {
+      const result = await this.uploadFileRetry(
+        bucketName,
+        file,
+        cancellationToken || new AbortController(),
+        onProgress,
+        maxWebWorker,
+        prefix,
+        initUpload,
+        customFileName,
+        worker,
+        dataUploadId
+      );
+      // Cleanup
+      cancellationToken?.signal.removeEventListener("abort", abortHandler);
+      return result;
+    } catch (error) {
+      // Cleanup
+      cancellationToken?.signal.removeEventListener("abort", abortHandler);
+      if (error instanceof Error && error.name === "AbortError") {
+        return new Promise((resolve, reject) => {
+          reject({
+            errorCode: "ClientAbort",
+            message: "Upload cancelled",
+          });
+        });
+      }
+
+      throw error;
+    }
+  }
+
+  public async uploadFileRetry(
+    bucketName: string,
+    file: File,
+    cancellationToken: AbortController,
+    onProgress?: (chunkUploaded: number) => void,
+    maxWebWorker?: number,
+    prefix?: string,
+    initUpload?: InitUploadResponse,
+    customFileName?: string,
+    worker?: Worker,
+    dataUploadId?: string
+  ) {
+    if (!this.accessToken)
+      return new Promise((resolve, reject) => {
+        reject("Access token is required");
+      });
+
+    // Check cancellation before starting
+    if (cancellationToken.signal.aborted) {
+      return new Promise((resolve, reject) => {
+        reject("Upload cancelled");
+      });
+    }
+
+    const fileSize = file.size;
+    const fileName =
+      prefix && prefix.length > 0
+        ? `${prefix.at(prefix.length - 1) === "/" ? prefix : prefix + "/"}${
+            customFileName ?? file.name
+          }`
+        : customFileName ?? file.name;
+    maxWebWorker = maxWebWorker ? maxWebWorker : ConfigFileRules.MaxWebWorker;
+    var service = new ServiceIntegration();
+    await service.validateFileSize(fileName, fileSize);
+
+    // Handle small file upload
+    if (fileSize <= ConfigFileRules.ChunkSize) {
+      const buffer = await readFileDataAsBase64(file);
+      const resUploadSmallFile = await service.uploadSmallFile(
+        bucketName,
+        fileName,
+        buffer,
+        this.accessToken,
+        cancellationToken,
+        onProgress,
+        undefined,
+        true
+      );
+      onProgress?.(buffer.length);
+      return resUploadSmallFile;
+    }
+
+    // Init multi upload
+    if (!initUpload) {
+      initUpload = await service.initMultiPartUpload(
+        bucketName,
+        fileName,
+        this.accessToken,
+        undefined,
+        cancellationToken
+      );
+      if (!initUpload) {
+        return new Promise((resolve, reject) => {
+          reject(`Fail to initiate multipart upload for file ${fileName}`);
+        });
+      }
+    }
+
+    var numberOfChunks: number = service.calculateNumberOfChunks(fileSize);
+    const urls = await service.generatePresignedUrls(
+      bucketName,
+      fileName,
+      initUpload,
+      numberOfChunks,
+      this.accessToken,
+      cancellationToken
+    );
+    if (!urls) {
+      return new Promise((resolve, reject) => {
+        reject(`Fail to generate presigned urls for file ${fileName}`);
+      });
+    }
+
+    const uploadChunks = async (chunkIndexs: number[]) => {
+      let chunkIndexErrors: number[] = [];
+      let responseUploadChilds: any[] = [];
+      const maxLimit =
+        chunkIndexs.length < ConfigFileRules.LimitFile
+          ? chunkIndexs.length
+          : ConfigFileRules.LimitFile;
+      const limit = pLimit(maxLimit);
+      // init worker
+      const workerPorts: MessagePort[] = [];
+      const maxWorker =
+        chunkIndexs.length < maxWebWorker ? chunkIndexs.length : maxWebWorker;
+      // Create workers
+      for (let index = 0; index < maxWorker; index++) {
+        const channel = new MessageChannel();
+        const worker = new Worker(
+          new URL("workerUploadChildFile", import.meta.url)
+        );
+        worker.postMessage({ port: channel.port2 }, [channel.port2]);
+        workerPorts.push(channel.port1);
+        this.workersStatus.push({
+          worker: worker,
+          taskNumber: 0,
+          id: index,
+          taskHandle: 0,
+        });
+      }
+      if (worker) {
+        worker.postMessage({ workerPorts }, workerPorts);
+      }
+
+      try {
+        // const tasks = Array.from({ length: numberOfChunks }, (_, index) => {
+        const tasks = chunkIndexs.map((index) => {
+          return limit(async () => {
+            // Check cancellation before each chunk
+            if (cancellationToken.signal.aborted) {
+              throw new Error("Upload cancelled");
+            }
+            try {
+              const chunkStart = index * ConfigFileRules.ChunkSize;
+              const chunkEnd = Math.min(
+                chunkStart + ConfigFileRules.ChunkSize,
+                fileSize
+              );
+              const chunk = file.slice(chunkStart, chunkEnd);
+              const arrayBuffer = await chunk.arrayBuffer();
+              var url: string = urls[index];
+
+              return this.runOnWorker({
+                currentPresignUrl: { url: url, headers: initUpload.headers },
+                arrayBuffer: arrayBuffer,
+                partNumber: index + 1,
+                onProgress: onProgress,
+                requestId: `${index + 1}-${Date.now()}`,
+                cancellationToken: cancellationToken,
+                dataUploadId: dataUploadId,
+                fileName: file.name,
+              });
+            } catch (error) {
+              chunkIndexErrors.push(index);
+            }
+          });
+        });
+
+        const results = await Promise.allSettled(tasks);
+
+        for (let i = 0; i < results.length; i++) {
+          if (results[i].status === "fulfilled") {
+            const responseUploadChild = (
+              results[i] as PromiseFulfilledResult<any>
+            ).value.responseUpload;
+            if (responseUploadChild) {
+              responseUploadChilds.push(responseUploadChild);
+            }
+          }
+        }
+
+        return { chunkIndexErrors, responseUploadChilds };
+      } catch (error) {
+        // Cleanup on error or cancellation
+        throw error;
+      } finally {
+        // Always cleanup workers
+        this.workersStatus.forEach((workerStatus) => {
+          workerStatus.worker.terminate();
+        });
+        this.workersStatus = [];
+      }
+    };
+
+    let currentRetry = 0;
+    const eTags: any = {};
+    let chunkIndexErrors: number[] = Array.from(
+      { length: numberOfChunks },
+      (_, index) => index
+    );
+    let responseUploadChilds: any[] = [];
+    do {
+      if (cancellationToken.signal.aborted) {
+        throw new Error("Upload cancelled");
+      }
+      const responseUploadChunks = await uploadChunks(chunkIndexErrors);
+      chunkIndexErrors = responseUploadChunks.chunkIndexErrors;
+      responseUploadChilds = responseUploadChilds.concat(
+        responseUploadChunks.responseUploadChilds
+      );
+
+      currentRetry++;
+    } while (
+      currentRetry < ConfigFileRules.MaxRetry &&
+      chunkIndexErrors.length > 0
+    );
+
+    if (chunkIndexErrors.length > 0) {
+      return new Promise((resolve, reject) => {
+        reject(
+          `Fail to upload chunks ${chunkIndexErrors} for file ${fileName}`
+        );
+      });
+    }
+    for (let i = 0; i < responseUploadChilds.length; i++) {
+      const responseUploadChild = responseUploadChilds[i];
+      Object.defineProperty(eTags, responseUploadChild.partNumber, {
+        value: responseUploadChild.eTag,
+        enumerable: true,
+      });
+    }
+
+    var completeResponse = await service.completeMultipartUpload(
+      bucketName,
+      fileName,
+      initUpload.uploadId,
+      eTags,
+      this.accessToken,
+      cancellationToken
+    );
+    onProgress?.(fileSize);
+
+    if (!completeResponse) {
+      throw new Error(`Fail to complete multipart upload for file ${fileName}`);
+    }
+
+    const objectDetail: any = await service.getObjectDetail(
+      bucketName,
+      fileName,
+      this.accessToken
+    );
+    if (!objectDetail) {
+      throw new Error(`Fail to get object detail for file ${fileName}`);
+    }
+
+    return {
+      bucketName: bucketName,
+      fileName: fileName,
+      contentLength: fileSize,
+      versionFile: objectDetail.versionId,
+      dateVersionFile: objectDetail.lastModified,
+    };
+  }
+
+  public async uploadFile(
+    bucketName: string,
+    file: File,
+    cancellationToken: AbortController,
+    onProgress?: (chunkUploaded: number) => void,
+    maxWebWorker?: number,
+    prefix?: string,
+    initUpload?: InitUploadResponse,
+    customFileName?: string,
+    worker?: Worker,
+    dataUploadId?: string
+  ) {
+    if (!this.accessToken)
+      return new Promise((resolve, reject) => {
+        reject("Access token is required");
+      });
+
+    // Check cancellation before starting
+    if (cancellationToken.signal.aborted) {
+      return new Promise((resolve, reject) => {
+        reject("Upload cancelled");
+      });
+    }
+
+    const fileSize = file.size;
+    const fileName =
+      prefix && prefix.length > 0
+        ? `${prefix.at(prefix.length - 1) === "/" ? prefix : prefix + "/"}${
+            customFileName ?? file.name
+          }`
+        : customFileName ?? file.name;
+    maxWebWorker = maxWebWorker ? maxWebWorker : ConfigFileRules.MaxWebWorker;
+    var service = new ServiceIntegration();
+    await service.validateFileSize(fileName, fileSize);
+
+    // Handle small file upload
+    if (fileSize <= ConfigFileRules.ChunkSize) {
+      const buffer = await readFileDataAsBase64(file);
+      const resUploadSmallFile = await service.uploadSmallFile(
+        bucketName,
+        fileName,
+        buffer,
+        this.accessToken,
+        cancellationToken,
+        onProgress,
+        undefined,
+        true
+      );
+      onProgress?.(buffer.length);
+      return resUploadSmallFile;
+    }
+
+    // Init multi upload
+    if (!initUpload) {
+      initUpload = await service.initMultiPartUpload(
+        bucketName,
+        fileName,
+        this.accessToken,
+        undefined,
+        cancellationToken
+      );
+      if (!initUpload) {
+        return new Promise((resolve, reject) => {
+          reject(`Fail to initiate multipart upload for file ${fileName}`);
+        });
+      }
+    }
+
+    var numberOfChunks: number = service.calculateNumberOfChunks(fileSize);
+    const urls = await service.generatePresignedUrls(
+      bucketName,
+      fileName,
+      initUpload,
+      numberOfChunks,
+      this.accessToken,
+      cancellationToken
+    );
+    if (!urls) {
+      return new Promise((resolve, reject) => {
+        reject(`Fail to generate presigned urls for file ${fileName}`);
+      });
+    }
+
+    const eTags: any = {};
+    const maxLimit =
+      numberOfChunks < ConfigFileRules.LimitFile
+        ? numberOfChunks
+        : ConfigFileRules.LimitFile;
+    const limit = pLimit(maxLimit);
+    // init worker
+    const workerPorts: MessagePort[] = [];
+    const maxWorker =
+      numberOfChunks < maxWebWorker ? numberOfChunks : maxWebWorker;
+    // Create workers
+    for (let index = 0; index < maxWorker; index++) {
+      const channel = new MessageChannel();
+      const worker = new Worker(
+        new URL("workerUploadChildFile", import.meta.url)
+      );
+      worker.postMessage({ port: channel.port2 }, [channel.port2]);
+      workerPorts.push(channel.port1);
+      this.workersStatus.push({
+        worker: worker,
+        taskNumber: 0,
+        id: index,
+        taskHandle: 0,
+      });
+    }
+    if (worker) {
+      worker.postMessage({ workerPorts }, workerPorts);
+    }
+
+    try {
+      const tasks = Array.from({ length: numberOfChunks }, (_, index) => {
+        return limit(async () => {
+          // Check cancellation before each chunk
+          if (cancellationToken.signal.aborted) {
+            throw new Error("Upload cancelled");
+          }
+
+          const chunkStart = index * ConfigFileRules.ChunkSize;
+          const chunkEnd = Math.min(
+            chunkStart + ConfigFileRules.ChunkSize,
+            fileSize
+          );
+          const chunk = file.slice(chunkStart, chunkEnd);
+          const arrayBuffer = await chunk.arrayBuffer();
+          var url: string = urls[index];
+
+          return this.runOnWorker({
+            currentPresignUrl: { url: url, headers: initUpload.headers },
+            arrayBuffer: arrayBuffer,
+            partNumber: index + 1,
+            onProgress: onProgress,
+            requestId: `${index + 1}-${Date.now()}`,
+            cancellationToken: cancellationToken,
+            dataUploadId: dataUploadId,
+            fileName: file.name,
+          });
+        });
+      });
+
+      const results = await Promise.all(tasks);
+
+      for (let i = 0; i < results.length; i++) {
+        const responseUploadChild = results[i].responseUpload;
+        if (!responseUploadChild) {
+          throw new Error(`Fail to upload chunk ${i} of file ${fileName}`);
+        }
+        Object.defineProperty(eTags, responseUploadChild.partNumber, {
+          value: responseUploadChild.eTag,
+          enumerable: true,
+        });
+      }
+
+      var completeResponse = await service.completeMultipartUpload(
+        bucketName,
+        fileName,
+        initUpload.uploadId,
+        eTags,
+        this.accessToken,
+        cancellationToken
+      );
+      onProgress?.(fileSize);
+
+      if (!completeResponse) {
+        throw new Error(
+          `Fail to complete multipart upload for file ${fileName}`
+        );
+      }
+
+      const objectDetail: any = await service.getObjectDetail(
+        bucketName,
+        fileName,
+        this.accessToken
+      );
+      if (!objectDetail) {
+        throw new Error(`Fail to get object detail for file ${fileName}`);
+      }
+
+      return {
+        bucketName: bucketName,
+        fileName: fileName,
+        contentLength: fileSize,
+        versionFile: objectDetail.versionId,
+        dateVersionFile: objectDetail.lastModified,
+      };
+    } catch (error) {
+      // Cleanup on error or cancellation
+      throw error;
+    } finally {
+      // Always cleanup workers
+      this.workersStatus.forEach((workerStatus) => {
+        workerStatus.worker.terminate();
+      });
+      this.workersStatus = [];
+    }
+  }
+
+  private async runOnWorker(data: ISingleFileUpload): Promise<any> {
+    const workerStatus = this.workersStatus.find(
+      (x) => x.taskNumber < ConfigFileRules.TaskCurrently
+    );
+    if (!workerStatus) return Promise.reject("No worker available");
+    // increase task number
+    workerStatus.taskNumber++;
+    const worker = workerStatus.worker;
+    return new Promise((resolve, reject) => {
+      if (typeof Worker !== "undefined") {
+        worker.addEventListener("message", (message: MessageEvent) => {
+          if (message.data.requestId !== data.requestId) return;
+
+          workerStatus.taskNumber--;
+          if (message.data && message.data.status === StatusWorker.Success) {
+            data.onProgress && data.onProgress(message.data.contentLength);
+            resolve(message.data);
+          } else {
+            reject(message.data);
+          }
+        });
+        worker.addEventListener("error", (error) => {
+          workerStatus.taskNumber--;
+          console.error(error);
+          reject(error);
+        });
+
+        // Add abort handler to worker
+        const abortHandler = () => {
+          worker.postMessage({
+            type: "abort",
+            requestId: data.requestId,
+          });
+        };
+        data.cancellationToken?.signal.addEventListener("abort", abortHandler);
+
+        const newData = {
+          currentPresignUrl: data.currentPresignUrl,
+          arrayBuffer: data.arrayBuffer,
+          partNumber: data.partNumber,
+          requestId: data.requestId,
+          dataUploadId: data.dataUploadId,
+          fileName: data.fileName,
+        };
+        worker.postMessage(newData, [data.arrayBuffer]);
+
+        // Cleanup abort handler when promise resolves or rejects
+        return () => {
+          data.cancellationToken?.signal.removeEventListener(
+            "abort",
+            abortHandler
+          );
+        };
+      } else {
+        console.error("Web Workers are not supported in this environment.");
+        reject("Web Workers are not supported in this environment.");
+      }
+    });
+  }
+  //#endregion
+  //#region Upload folder
+  public async uploadFolderAferInit(
+    filesInitiated: {
+      file: File;
+      fileKey: string;
+      path: string;
+      initUpload?: InitUploadResponse;
+      isGetInfo?: boolean;
+    }[],
+    cancellationToken?: AbortController,
+    worker?: Worker,
+    dataUploadId?: string,
+    onProgress?: ({
+      percentCompleted,
+      fileKey,
+      versionFile,
+    }: {
+      percentCompleted: number;
+      fileKey: string;
+      versionFile?: string;
+    }) => void,
+    maxWebWorker?: number
+  ) {
+    const bucketName = filesInitiated[0].path.split("/").at(0);
+    if (!bucketName)
+      return new Promise((resolve, reject) => {
+        reject("Path is not valid");
+      });
+
+    if (cancellationToken?.signal.aborted) {
+      return new Promise((resolve, reject) => {
+        reject("Upload cancelled");
+      });
+    }
+
+    const abortHandler = () => {
+      // Cleanup workers
+      this.workersStatus.forEach((workerStatus) => {
+        workerStatus.worker.terminate();
+      });
+      this.workersStatus = [];
+    };
+    cancellationToken?.signal.addEventListener("abort", abortHandler);
+
+    try {
+      const result = await this.uploadFolder(
+        bucketName,
+        filesInitiated.map((x) => ({
+          file: x.file,
+          fileKey: x.fileKey,
+          customFileName: x.path.split("/").slice(1).join("/"),
+          initUpload: x.initUpload,
+          isGetInfo: x.isGetInfo,
+        })),
+        cancellationToken || new AbortController(),
+        worker,
+        dataUploadId,
+        onProgress,
+        maxWebWorker
+      );
+      // Cleanup
+      cancellationToken?.signal.removeEventListener("abort", abortHandler);
+      return result;
+    } catch (error) {
+      // Cleanup
+      cancellationToken?.signal.removeEventListener("abort", abortHandler);
+      if (error instanceof Error && error.name === "AbortError") {
+        return new Promise((resolve, reject) => {
+          reject({
+            errorCode: "ClientAbort",
+            message: "Upload cancelled",
+          });
+        });
+      }
+      throw error;
+    }
+  }
+
+  public async uploadFolder(
+    bucketName: string,
+    files: FileUploadType[],
+    cancellationToken: AbortController,
+    worker?: Worker,
+    dataUploadId?: string,
+    onProgress?: ({
+      percentCompleted,
+      fileKey,
+      versionFile,
+    }: {
+      percentCompleted: number;
+      fileKey: string;
+      versionFile?: string;
+    }) => void,
+    maxWebWorker?: number,
+    prefix?: string
+  ): Promise<any> {
+    try {
+      if (!this.accessToken)
+        return new Promise((resolve, reject) => {
+          reject("Access token is required");
+        });
+
+      // Check cancellation before starting
+      if (cancellationToken.signal.aborted) {
+        return new Promise((resolve, reject) => {
+          reject({
+            errorCode: "ClientAbort",
+            message: "Upload cancelled",
+          });
+        });
+      }
+
+      prefix =
+        prefix && prefix.length > 0
+          ? `${prefix.at(prefix.length - 1) === "/" ? prefix : prefix + "/"}`
+          : "";
+      maxWebWorker = maxWebWorker ? maxWebWorker : ConfigFileRules.MaxWebWorker;
+      let percentOneBuffer = 100 / files.length;
+      let currentPercent = 0;
+      let currentRetry = 0;
+      const percentOfChild = ({
+        fileKey,
+        versionFile,
+      }: {
+        fileKey: string;
+        versionFile?: string;
+      }) => {
+        currentPercent += percentOneBuffer;
+        onProgress?.({
+          percentCompleted: Math.floor(currentPercent),
+          fileKey: fileKey,
+          versionFile: versionFile,
+        });
+      };
+
+      let filesUploadFail: FileUploadType[] | undefined = files;
+      let filesUploadSuccess:
+        | {
+            file: File;
+            customFileName?: string;
+            versionFile?: string;
+          }[]
+        | undefined = [];
+      do {
+        // Check cancellation before each retry
+        if (cancellationToken.signal.aborted) {
+          throw new Error("Upload cancelled");
+        }
+        const resUpload = await this.uploadMultiFileRetry(
+          bucketName,
+          filesUploadFail,
+          this.accessToken,
+          cancellationToken,
+          maxWebWorker,
+          this.reFreshToken,
+          percentOfChild,
+          prefix,
+          worker,
+          dataUploadId
+        );
+        currentRetry++;
+        if (resUpload) {
+          filesUploadFail = resUpload.filesUploadFail ?? [];
+          filesUploadSuccess = filesUploadSuccess.concat(
+            resUpload.filesUploadSuccess ?? []
+          );
+        } else {
+          return new Promise((resolve, reject) => {
+            reject("Fail to upload files");
+          });
+        }
+      } while (
+        currentRetry < ConfigFileRules.MaxRetry &&
+        filesUploadFail &&
+        filesUploadFail.length > 0
+      );
+      // get list file upload fail
+      if (!filesUploadFail)
+        return new Promise((resolve, reject) => {
+          reject("Fail to upload files");
+        });
+      const filesNameUploadFail: string[] = filesUploadFail.map((file) => {
+        return file.customFileName ?? file.file.webkitRelativePath;
+      });
+
+      // if(worker) {
+      //   worker.postMessage({
+      //     type: "progressUpload",
+      //     progress: {
+      //       dataUploadId: dataUploadId,
+      //       percentCompleted: 100,
+      //       fileKey: "",
+      //       versionFile: "",
+      //     },
+      //   });
+      // }
+
+      return new Promise((resolve, reject) => {
+        if (filesNameUploadFail.length === files.length)
+          reject("Fail to upload all files");
+        else
+          resolve({
+            uploadFail: {
+              totalFile: filesNameUploadFail.length,
+              filesName: filesNameUploadFail,
+            },
+            uploadSuccess: {
+              totalFile: files.length - filesNameUploadFail.length,
+              files: filesUploadSuccess.map((file) => ({
+                fileName: file.customFileName ?? file.file.webkitRelativePath,
+                versionFile: file.versionFile,
+              })),
+            },
+          });
+      });
+    } catch (error) {
+      console.error("uploadMultiFile", error);
+      if (error instanceof Error && error.message === "Upload cancelled") {
+        return new Promise((resolve, reject) => {
+          reject({
+            errorCode: "ClientAbort",
+            message: "Upload cancelled",
+          });
+        });
+      }
+      return new Promise((resolve, reject) => {
+        reject(error);
+      });
+    }
+  }
+
+  public async uploadMultiFileRetry(
+    bucketName: string,
+    files: FileUploadType[],
+    accessToken: string,
+    cancellationToken: AbortController,
+    maxWebWorker: number,
+    reFreshToken?: () => Promise<string>,
+    percentOfChild?: ({
+      fileKey,
+      versionFile,
+    }: {
+      fileKey: string;
+      versionFile?: string;
+    }) => void,
+    prefix?: string,
+    worker?: Worker,
+    dataUploadId?: string
+  ): Promise<
+    | {
+        filesUploadFail: FileUploadType[] | undefined;
+        filesUploadSuccess:
+          | {
+              file: File;
+              customFileName?: string;
+              versionFile?: string;
+            }[]
+          | undefined;
+      }
+    | undefined
+  > {
+    try {
+      if (cancellationToken.signal.aborted) {
+        throw new Error("Upload cancelled");
+      }
+
+      const service = new ServiceIntegration();
+      const batchSize = 2000;
+      const triggerNextBatchAt = 1000;
+      let currentBatchIndex = 0;
+      let filesUploadFail: FileUploadType[] = [];
+      let filesUploadSuccess: {
+        file: File;
+        customFileName?: string;
+        versionFile?: string;
+      }[] = [];
+
+      // Atomic counter for uploaded files
+      let isFetchingNextBatch = false;
+
+      // Function to fetch presignUrls for a batch
+      const fetchPresignUrlsForBatch = async (batchFiles: FileUploadType[]) => {
+        const multiPresignUrl = await service.generateMultiPresignedUrl(
+          bucketName,
+          batchFiles
+            .filter((x) => x.file.size <= ConfigFileRules.ChunkSize)
+            .map((file) => {
+              const customFileName =
+                file.customFileName ?? file.file.webkitRelativePath;
+              return `${prefix ?? ""}${
+                customFileName.startsWith("/")
+                  ? customFileName.slice(1)
+                  : customFileName
+              }`;
+            }),
+          accessToken,
+          cancellationToken
+        );
+
+        if (multiPresignUrl) {
+          batchFiles.forEach((file) => {
+            const customFileName =
+              file.customFileName ?? file.file.webkitRelativePath;
+            const fileName = `${prefix ?? ""}${
+              customFileName.startsWith("/")
+                ? customFileName.slice(1)
+                : customFileName
+            }`;
+            const preSignUrl = multiPresignUrl.urls[fileName];
+            if (preSignUrl) {
+              file.preSignUrl = {
+                url: preSignUrl,
+                headers: multiPresignUrl.headers,
+              };
+            }
+          });
+        }
+        return multiPresignUrl;
+      };
+
+      // Function to prepare next batch
+      const prepareNextBatch = async () => {
+        if (
+          isFetchingNextBatch ||
+          !((currentBatchIndex + 1) * batchSize < files.length)
+        )
+          return;
+
+        isFetchingNextBatch = true;
+        try {
+          const nextBatchStart = (currentBatchIndex + 1) * batchSize;
+          const nextBatchEnd = Math.min(
+            (currentBatchIndex + 2) * batchSize,
+            files.length
+          );
+          const nextBatchFiles = files.slice(nextBatchStart, nextBatchEnd);
+          await fetchPresignUrlsForBatch(nextBatchFiles);
+        } finally {
+          isFetchingNextBatch = false;
+        }
+      };
+
+      // init worker
+      const workerPorts: MessagePort[] = [];
+      const maxWorker =
+        files.length < maxWebWorker ? files.length : maxWebWorker;
+      for (let index = 0; index < maxWorker; index++) {
+        const channel = new MessageChannel();
+        const worker = new Worker(
+          new URL("workerUploadSingleFile", import.meta.url)
+        );
+        worker.postMessage({ port: channel.port2 }, [channel.port2]);
+        workerPorts.push(channel.port1);
+        this.workersStatus.push({
+          worker: worker,
+          taskNumber: 0,
+          id: index,
+          taskHandle: 0,
+        });
+      }
+      if (worker) {
+        worker.postMessage({ workerPorts }, workerPorts);
+      }
+
+      while (currentBatchIndex * batchSize < files.length) {
+        const batchStart = currentBatchIndex * batchSize;
+        const batchEnd = Math.min(
+          (currentBatchIndex + 1) * batchSize,
+          files.length
+        );
+        const batchFiles = files.slice(batchStart, batchEnd);
+
+        // Get presignUrls for current batch
+        await fetchPresignUrlsForBatch(batchFiles);
+
+        const maxLimit =
+          batchFiles.length < ConfigFileRules.LimitFile
+            ? batchFiles.length
+            : ConfigFileRules.LimitFile;
+
+        const limit = pLimit(maxLimit);
+
+        const tasks = batchFiles.map((file, idx) =>
+          limit(async () => {
+            if (cancellationToken.signal.aborted)
+              throw new Error("Upload cancelled");
+            try {
+              let arrayBuffer: ArrayBuffer | null =
+                await file.file.arrayBuffer();
+              const res = await this.uploadSingleFile({
+                ...file,
+                bucketName,
+                arrayBuffer: arrayBuffer,
+                index: idx,
+                requestId: `${idx}-${Date.now()}`,
+                fullName: `${prefix ?? ""}${
+                  (
+                    file.customFileName ?? file.file.webkitRelativePath
+                  ).startsWith("/")
+                    ? (
+                        file.customFileName ?? file.file.webkitRelativePath
+                      ).slice(1)
+                    : file.customFileName ?? file.file.webkitRelativePath
+                }`,
+                accessToken,
+                percentOfChild,
+                cancellationToken,
+                dataUploadId,
+              });
+              arrayBuffer = null;
+              filesUploadSuccess.push({
+                ...file,
+                versionFile: res.responseUpload?.versionFile,
+              });
+              if (idx === triggerNextBatchAt) {
+                prepareNextBatch();
+              }
+            } catch (err) {
+              filesUploadFail.push(file);
+            }
+          })
+        );
+
+        await Promise.allSettled(tasks);
+        currentBatchIndex++;
+      }
+
+      return {
+        filesUploadFail,
+        filesUploadSuccess,
+      };
+    } catch (error) {
+      console.error("uploadMultiFileRetry", error);
+      // Cleanup workers on error
+      this.workersStatus.forEach((workerStatus) => {
+        workerStatus.worker.terminate();
+      });
+      this.workersStatus = [];
+
+      if (error instanceof Error && error.message === "Upload cancelled") {
+        throw error; // Re-throw cancel error to be handled by caller
+      }
+      return undefined;
+    }
+  }
+
+  uploadSingleFile = async (request: IMultiFileUpload): Promise<any> => {
+    const workerStatus = this.workersStatus.find(
+      (x) => x.taskNumber < ConfigFileRules.TaskCurrently
+    );
+    if (!workerStatus) return Promise.reject("No worker available");
+
+    // Check cancellation before starting
+    if (request.cancellationToken?.signal.aborted) {
+      return Promise.reject(new Error("Upload cancelled"));
+    }
+
+    // increase task number
+    workerStatus.taskNumber++;
+    const worker = workerStatus.worker;
+    return new Promise((resolve, reject) => {
+      if (typeof Worker !== "undefined") {
+        worker.addEventListener("message", (message: MessageEvent) => {
+          if (message.data.requestId !== request.requestId) return;
+
+          workerStatus.taskNumber--;
+          if (message.data && message.data.status === StatusWorker.Success) {
+            request.percentOfChild &&
+              request.percentOfChild({
+                fileKey: message.data.fileKey,
+                versionFile: message.data.responseUpload.versionFile,
+              });
+            resolve(message.data);
+          } else {
+            reject(message.data);
+          }
+        });
+        worker.addEventListener("error", (error) => {
+          workerStatus.taskNumber--;
+          console.error(error);
+          reject(error);
+        });
+
+        // Add abort handler to worker
+        const abortHandler = () => {
+          worker.postMessage({
+            type: "abort",
+            requestId: request.requestId,
+          });
+          worker.terminate();
+          reject(new Error("Upload cancelled"));
+        };
+        request.cancellationToken?.signal.addEventListener(
+          "abort",
+          abortHandler
+        );
+
+        const newData = {
+          bucketName: request.bucketName,
+          fullName: request.fullName,
+          arrayBuffer: request.arrayBuffer,
+          requestId: request.requestId,
+          workerId: workerStatus.id,
+          accessToken: request.accessToken,
+          fileKey: request.fileKey,
+          initUpload: request.initUpload,
+          isGetInfo: request.isGetInfo,
+          preSignUrl: request.preSignUrl,
+          dataUploadId: request.dataUploadId,
+        };
+        worker.postMessage(newData, [request.arrayBuffer]);
+
+        // Cleanup abort handler when promise resolves or rejects
+        return () => {
+          request.cancellationToken?.signal.removeEventListener(
+            "abort",
+            abortHandler
+          );
+        };
+      } else {
+        console.error("Web Workers are not supported in this environment.");
+        reject("Web Workers are not supported in this environment.");
+      }
+    });
+  };
+
+  //#endregion
+  //#region Download file
+  // public async downloadFile(
+  //   bucketName: string,
+  //   fileName: string,
+  //   cancellationToken: AbortController,
+  //   onProgress?: (percentCompleted: number) => void,
+  //   maxWebWorker?: number
+  // ) {
+  //   try {
+  //     maxWebWorker = maxWebWorker ? maxWebWorker : ConfigFileRules.MaxWebWorker;
+  //     var serviceIntegrate = new ServiceIntegration();
+  //     const file = await serviceIntegrate.getObjectDetail(
+  //       bucketName,
+  //       fileName,
+  //       this.accessToken
+  //     );
+  //     if (!file || !file.contentLength || file.contentLength === 0) {
+  //       return new Promise((resolve, reject) => {
+  //         reject("File not found");
+  //       });
+  //     }
+  //     const url = await serviceIntegrate.getUrlToDownload(
+  //       bucketName,
+  //       fileName,
+  //       this.accessToken
+  //     );
+  //     if (!url)
+  //       return new Promise((resolve, reject) => {
+  //         reject("Fail to get url download");
+  //       });
+  //     const numberOfChunks = Math.ceil(
+  //       file.contentLength / ConfigFileRules.ChunkSize
+  //     );
+  //     const maxWorker = Math.min(numberOfChunks, maxWebWorker);
+  //     const maxLimit = Math.min(numberOfChunks, ConfigFileRules.LimitFile);
+  //     const limit = pLimit(maxLimit);
+  //     let start = 0;
+  //     const totalSize = file.contentLength;
+  //     for (let index = 0; index < maxWorker; index++) {
+  //       this.workersStatus.push({
+  //         worker: new Worker(
+  //           new URL("workerDownloadSingleFile", import.meta.url)
+  //         ),
+  //         taskNumber: 0,
+  //         id: index,
+  //         taskHandle: 0,
+  //       });
+  //     }
+  //     const newFileName = fileName.split("/").at(-1);
+  //     const fileWriter = streamSaver.createWriteStream(`${newFileName}`);
+  //     const writer = fileWriter.getWriter();
+  //     const chunksQueue: (Uint8Array | undefined)[] = [];
+  //     let nextChunkIndex = 0;
+  //     const handleChunk = async (chunk: Uint8Array, index: number) => {
+  //       chunksQueue[index] = chunk;
+  //       while (chunksQueue[nextChunkIndex]) {
+  //         nextChunkIndex++; // hack duplicate chunk :D
+  //         await writer.write(chunksQueue[nextChunkIndex - 1]);
+  //         chunksQueue[nextChunkIndex - 1] = undefined; // Clear memory
+  //       }
+  //     };
+  //     const chunksData: any[] = [];
+  //     Array.from({ length: numberOfChunks }, (_, index) => {
+  //       const end = Math.min(
+  //         start + ConfigFileRules.ChunkSize - 1,
+  //         totalSize - 1
+  //       );
+  //       chunksData.push({
+  //         url: url,
+  //         start: start,
+  //         end: end,
+  //         index: index,
+  //         requestId: `${index + 1}-${Date.now()}`,
+  //       });
+  //       start += ConfigFileRules.ChunkSize;
+  //     });
+  //     // hack to client chose location to save file
+  //     const firstChunk = chunksData.shift();
+  //     const firstData = await this.downloadSingleLargeFile(
+  //       firstChunk.index,
+  //       firstChunk.url,
+  //       firstChunk.start,
+  //       firstChunk.end,
+  //       firstChunk.requestId
+  //     );
+  //     await handleChunk(new Uint8Array(firstData.chunk), firstData.index);
+  //     const tasks = chunksData.map((data) => {
+  //       return limit(async () => {
+  //         let task = await this.downloadSingleLargeFile(
+  //           data.index,
+  //           data.url,
+  //           data.start,
+  //           data.end,
+  //           data.requestId
+  //         );
+  //         await handleChunk(new Uint8Array(task.chunk), task.index);
+  //         return task;
+  //       });
+  //     });
+
+  //     await Promise.all(tasks);
+  //     await writer.close();
+  //     this.workersStatus.forEach((workerStatus) => {
+  //       workerStatus.worker.terminate();
+  //     });
+  //     this.workersStatus = [];
+
+  //     return new Promise((resolve, reject) => {
+  //       resolve({
+  //         downloadSuccess: {
+  //           totalFile: numberOfChunks,
+  //           blobUrl: fileWriter,
+  //           fileName: `${newFileName}`,
+  //         },
+  //       });
+  //     });
+  //   } catch (error) {
+  //     console.error("downloadLargeFile", error);
+  //     return new Promise((resolve, reject) => {
+  //       reject(error);
+  //     });
+  //   }
+  // }
+
+  private async downloadSingleLargeFile(
+    index: number,
+    url: string,
+    start: number,
+    end: number,
+    requestId: string
+  ): Promise<any> {
+    try {
+      const workerStatus = this.workersStatus.find(
+        (x) => x.taskNumber < ConfigFileRules.TaskCurrently
+      );
+      if (!workerStatus) return Promise.reject("No worker available");
+      // increase task number
+      workerStatus.taskNumber++;
+      const worker = workerStatus.worker;
+      return new Promise((resolve, reject) => {
+        if (typeof Worker !== "undefined") {
+          worker.addEventListener("message", async (message: MessageEvent) => {
+            if (message.data.requestId !== requestId) return;
+
+            workerStatus.taskNumber--;
+            if (message.data && message.data.status === StatusWorker.Success) {
+              resolve(message.data);
+            } else {
+              reject(message.data);
+            }
+          });
+          worker.addEventListener("error", (error) => {
+            workerStatus.taskNumber--;
+            console.error(error);
+            reject(error);
+          });
+
+          const newData = {
+            index: index,
+            url: url,
+            start: start,
+            end: end,
+            requestId: requestId,
+          };
+          worker.postMessage(newData);
+        } else {
+          console.error("Web Workers are not supported in this environment.");
+          reject("Web Workers are not supported in this environment.");
+        }
+      });
+    } catch (error) {
+      console.error(`Error when download file: ${error}`);
+      throw error;
+    }
+  }
+  //#endregion
+  //#region Translate
+  public async translateFile(
+    request: TranslateRequest
+  ): Promise<TranslateInfo> {
+    return await this.baseAction<TranslateInfo>((accessToken: string) => {
+      return TranslateFile(accessToken, request);
+    });
+  }
+
+  public async getStatusTranslate(request: string[]): Promise<any> {
+    return await this.baseAction<TranslateStatusInfo[]>(
+      (accessToken: string) => {
+        return GetStatusTranslate(accessToken, request);
+      }
+    );
+  }
+
+  public async getStatusTranslateFile(
+    request: GetStatusTranslateRequest[]
+  ): Promise<any> {
+    return await this.baseAction<TranslateStatusInfo[]>(
+      (accessToken: string) => {
+        return GetStatusTranslateFile(accessToken, request);
+      }
+    );
+  }
+
+  public async getEPSGRegionCode(): Promise<string[]> {
+    return await this.baseAction<string[]>((accessToken: string) => {
+      return GetEPSGRegionCode(accessToken);
+    });
+  }
+
+  public async getFileTileSet(translateId: string): Promise<string> {
+    return await this.baseAction<string>((accessToken: string) => {
+      return GetFileTileSet(accessToken, translateId);
+    });
+  }
+  //#endregion
+  //#region Authentication
+  public async getToken(
+    clientId: string,
+    clientSecret: string,
+    scopes: Scope[]
+  ): Promise<Token> {
+    return await this.baseActionAnonymous<Token>(() => {
+      return GetToken(clientId, clientSecret, scopes);
+    });
+  }
+  //#endregion
+
+  public async delay(ms: number) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+}