dpu-cloud-sdk 1.0.0

package/src/api/auth.ts

@@ -0,0 +1,18 @@
+import { BaseReponseModel, Token } from "../models/ResponseModel";
+import { Path, PathAuth } from "../utils/Constants";
+import { Scope } from "../utils/Enum";
+import { baseFetch } from "./translate";
+
+export const GetToken = async (clientId: string, clientSecret: string, scopes: Scope[]): Promise<BaseReponseModel<Token>> => {
+    const request = {
+        clientId,
+        clientSecret,
+        scopes: [0,1,2,3,4,5,6,7,8,9,10,11,12]
+    }
+    return baseFetch<Token, typeof request>(
+        `${Path.BaseURL}${PathAuth.GetToken}`,
+        "POST",
+        "",
+        request
+    );
+}

package/src/api/compress.ts

@@ -0,0 +1,36 @@
+import { CompressFolderRequest, GetStatusCompressionRequest } from "../models/RequestModel";
+import { BaseReponseModel, CompressionResponse, CompressStatus } from "../models/ResponseModel";
+import { Path, PathManagement } from "../utils/Constants";
+import { baseFetch } from "./translate";
+
+export const CompressFolder = async (accessToken: string, bucketName: string, rootFolder?: string): Promise<BaseReponseModel<CompressionResponse>> => {
+    return baseFetch<CompressionResponse, CompressFolderRequest>(
+        `${Path.BaseURL}${PathManagement.CompressFolder}`,
+        "POST",
+        accessToken,
+        {
+            bucketName,
+            rootFolder
+        }
+    );
+};
+
+export const GetStatusCompress = async (requestIds: string[], accessToken: string): Promise<BaseReponseModel<CompressStatus>> => {
+    return baseFetch<CompressStatus, GetStatusCompressionRequest>(
+        `${Path.BaseURL}${PathManagement.GetStatusCompress}`,
+        "POST",
+        accessToken,
+        {
+            requestIds
+        }
+    );
+};
+
+export const CancelDownload = async (requestId: string, accessToken: string): Promise<BaseReponseModel<boolean>> => {
+    return baseFetch<boolean, string>(
+        `${Path.BaseURL}${PathManagement.CancelDownload}`,
+        "DELETE",
+        accessToken,
+        requestId
+    );
+};

package/src/api/translate.ts

@@ -0,0 +1,94 @@
+import {
+  GetStatusTranslateRequest,
+  TranslateRequest,
+} from "../models/RequestModel";
+import {
+  BaseReponseModel,
+  TranslateInfo,
+  TranslateStatusInfo,
+} from "../models/ResponseModel";
+import { ApiStatus, Path, PathManagement } from "../utils/Constants";
+
+export const baseFetch = async <T, T1>(
+  url: string,
+  method: string,
+  accessToken: string,
+  request?: T1
+): Promise<BaseReponseModel<T>> => {
+  const response = await fetch(url, {
+    method: method,
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${accessToken}`,
+      'ngrok-skip-browser-warning': true
+    } as any,
+    body: JSON.stringify(request),
+  });
+  if (response.ok) return response.json();
+  if (response.status === 401)
+    return {
+      statusCode: ApiStatus.Unauthorized,
+      message: "Unauthorized",
+      data: null,
+    } as BaseReponseModel<T>;
+  return new Promise((resolve, reject) => {
+    reject(response.text);
+  });
+};
+
+export const TranslateFile = async (
+  accessToken: string,
+  request: TranslateRequest
+): Promise<BaseReponseModel<TranslateInfo>> => {
+  return baseFetch<TranslateInfo, TranslateRequest>(
+    `${Path.BaseURL}${PathManagement.TranslateFile}`,
+    "POST",
+    accessToken,
+    request
+  );
+};
+
+export const GetStatusTranslate = async (
+  accessToken: string,
+  request: string[]
+): Promise<BaseReponseModel<TranslateStatusInfo[]>> => {
+  return baseFetch<TranslateStatusInfo[], string[]>(
+    `${Path.BaseURL}${PathManagement.GetStatusTranslate}`,
+    "POST",
+    accessToken,
+    request
+  );
+};
+
+export const GetStatusTranslateFile = async (
+  accessToken: string,
+  request: GetStatusTranslateRequest[]
+): Promise<BaseReponseModel<TranslateStatusInfo[]>> => {
+    return baseFetch<TranslateStatusInfo[], GetStatusTranslateRequest[]>(
+        `${Path.BaseURL}${PathManagement.GetStatusTranslateFile}`,
+        "POST",
+        accessToken,
+        request
+    );
+};
+
+export const GetEPSGRegionCode = async (
+  accessToken: string
+): Promise<BaseReponseModel<string[]>> => {
+  return baseFetch<string[], undefined>(
+    `${Path.BaseURL}${PathManagement.GetEPSGRegionCode}`,
+    "GET",
+    accessToken,
+  );
+};
+
+export const GetFileTileSet = async (
+    accessToken: string,
+    translateId: string
+  ): Promise<BaseReponseModel<string>> => {  
+    return baseFetch<string, undefined>(
+      `${Path.BaseURL}${PathManagement.GetFileTileSet}?translateId=${translateId}`,
+      "GET",
+      accessToken,
+    );
+  };

package/src/index.ts

@@ -0,0 +1,4 @@
+export * from "./DPUClient";
+export * from "./models/RequestModel";
+export * from "./models/ResponseModel";
+export { dpuConfig } from "./utils/Config";

package/src/models/RequestModel.ts

@@ -0,0 +1,44 @@
+export type FileDownloadInfo = {
+  fullName: string;
+  contentLength?: number;
+};
+
+//#region Compress
+export type CompressFolderRequest = {
+  bucketName: string;
+  rootFolder?: string;
+};
+
+export type GetStatusCompressionRequest = {
+  requestIds: string[];
+};
+//#endregion
+
+//#region Translate
+export interface TranslateRequest {
+  modelType: string;
+  epsgCode: string;
+  translatePos?: number[];
+}
+
+export interface FileTranslateRequest extends TranslateRequest {
+    bucketName?: string;
+    fileName?: string;
+    versionId?: string;
+    url?: string;
+}
+
+export interface URNTranslateRequest extends TranslateRequest {
+    urn?: string;
+    accessToken: string | null;
+    clientId: string | null;
+    clientSecret: string | null;
+}
+
+export interface GetStatusTranslateRequest {
+  bucketName: string;
+  fileName: string;
+  versionId: string;
+}
+
+//#endregion

package/src/models/ResponseModel.ts

@@ -0,0 +1,110 @@
+import { StatusTranslate } from "../utils/Enum";
+
+export type BaseReponseModel<T> = {
+    statusCode: number,
+    message: string,
+    data: T
+}
+
+export interface PresignURLResponse {
+    url: string;
+    headers: { [key: string]: string; };
+}
+
+export interface MultiPresignURLResponse {
+    urls: { [key: string]: string; };
+    headers: { [key: string]: string; };
+}
+
+export interface InitUploadResponse {
+    uploadId: string;
+    headers: { [key: string]: string; };
+}
+
+export type CompressionResponse = {
+    bucketName: string;
+    rootFolder: string;
+    requestId: string;
+}
+
+export interface CompressStatus {
+    compressData: CompressResponse;
+    compressInfo: FileCompressInfo;
+}
+
+export interface FileCompressInfo {
+    bucketName: string;
+    rootFolder: string;
+    requestId: string;
+}
+
+export interface CompressResponse {
+    status: CompressStatus;  
+    percent: number;
+    fileCompressed: number;
+    totalFile: number;
+    urlsDownload: string[] | null;
+    expireTime: Date | null;
+    compressTime: Date;
+    message: string[];
+}
+
+export interface ObjectDetail {
+    bucketKey: string;
+    lastModified: string;
+    versionId: string;
+    objectKey: string;
+    contentLength: number | null;
+}
+
+export interface CompleteMultipartUploadResponse {
+    key: string;
+    eTag: string;
+    versionId: string;
+}
+
+export interface TranslateStatusInfo {
+    translateId: string;
+    modelType: string;
+    translateType: string;
+    extensionSaveFile: string;
+    ePSGCode: string;
+    translatePos: number[] | null;
+    translateStatus: TranslateStatus;
+    objectTranslateInfo: ObjectTranslateInfo;
+}
+
+export interface ObjectTranslateInfo {
+
+}
+
+export interface FileTranslateInfo extends ObjectTranslateInfo {
+    fileName: string;
+    bucketName: string;
+    versionId: string;
+}
+
+export interface URNTranslateInfo extends ObjectTranslateInfo {
+    urn: string;
+    clientID: string;
+}
+
+export interface TranslateStatus {
+    status: StatusTranslate;
+    percentTranslateGeometry: number | null;
+    percentTranslateMetadata: number | null;
+}
+
+export interface Token{
+    accessToken: string;
+    expiresIn: number;
+}
+
+export interface Dictionary<T> {
+    [key: string]: T;
+}
+
+export interface TranslateInfo {
+    listError: Dictionary<string>;
+    translateStatusInfo: TranslateStatusInfo[];
+}

package/src/utils/Config.ts

@@ -0,0 +1,59 @@
+/**
+ * Global configuration for DPU Storage
+ * This allows external packages to customize the BaseURL for their domains
+ */
+interface IConfig {
+  baseURL: string;
+}
+
+class DPUConfig {
+  private static instance: DPUConfig;
+  private config: IConfig = {
+    baseURL: 'https://translateservicedev.corebim.com', // Default URL
+  };
+
+  private constructor() {}
+
+  public static getInstance(): DPUConfig {
+    if (!DPUConfig.instance) {
+      DPUConfig.instance = new DPUConfig();
+    }
+    return DPUConfig.instance;
+  }
+
+  /**
+   * Set the base URL for API requests
+   * @param baseURL The base URL for all API calls
+   */
+  public setBaseURL(baseURL: string): void {
+    if (!baseURL || typeof baseURL !== 'string') {
+      throw new Error('Invalid baseURL. Must be a non-empty string.');
+    }
+    this.config.baseURL = baseURL.trim();
+  }
+
+  /**
+   * Get the current base URL
+   */
+  public getBaseURL(): string {
+    return this.config.baseURL;
+  }
+
+  /**
+   * Set multiple configuration values at once
+   */
+  public setConfig(config: Partial<IConfig>): void {
+    if (config.baseURL) {
+      this.setBaseURL(config.baseURL);
+    }
+  }
+
+  /**
+   * Get the entire configuration object
+   */
+  public getConfig(): IConfig {
+    return { ...this.config };
+  }
+}
+
+export const dpuConfig = DPUConfig.getInstance();

package/src/utils/Constants.ts

@@ -0,0 +1,61 @@
+import { dpuConfig } from './Config';
+
+export const Path = {
+    get BaseURL() {
+        return dpuConfig.getBaseURL();
+    },
+    InitiateMultipartUpload: '/fileApi/Object/InitiateMultipartUpload',
+    GeneratePresignedUrls: '/fileApi/Object/GeneratePresignedUrls',
+    GeneratePresignedUrl: '/fileApi/Object/GeneratePresignedUrl',
+    GenerateMultiPresignedURL: '/fileApi/Object/GenerateMultiPresignedURL',
+    CompleteMultipartUpload: '/fileApi/Object/CompleteMultipartUpload',
+    AbortMultipartUpload: '/fileApi/Object/AbortMultipartUpload',
+    GetObjectDetail: '/fileApi/Object/GetObjectDetail',
+    GetObjects: '/fileApi/Object/GetObjects',
+    GetUrlDownload: '/fileApi/Object/GetUrlDownload',
+    ApplyPermissionToObjects: '/fileApi/Object/ApplyPermissionToObjects',
+}
+
+export const PathManagement = {
+    //#region Compress
+    CompressFolder: "/manageTranslateApi/Compress/CompressFolder",
+    GetStatusCompress: "/manageTranslateApi/Compress/GetStatusCompress",
+    CancelDownload: "/manageTranslateApi/Compress/CancelDownload",
+    //#endregion
+    //#region Translate
+    TranslateFile: "/manageTranslateApi/Translate/TranslateFile",
+    GetStatusTranslate: "/manageTranslateApi/Translate/GetStatusTranslate",
+    GetStatusTranslateFile: "/manageTranslateApi/Translate/GetStatusTranslateFile",
+    GetEPSGRegionCode: "/manageTranslateApi/Translate/GetEPSGRegionCode",
+    GetFileTileSet: "/manageTranslateApi/Translate/GetFileTileSet",
+    //#endregion
+}
+
+export const PathAuth = {
+    GetToken: '/authApi/user/GetToken',
+}
+
+export const ApiStatus = {
+    Success: 200,
+    BadRequest: 400,
+    Unauthorized: 401,
+    Forbidden: 403,
+    NotFound: 404,
+    InternalServerError: 500
+}
+
+export const ConfigFileRules = {
+    ChunkSize: 5 * 1024 * 1024, // 5MB
+    MaxChunkCountAllowed: 10000,
+    MaxRetryOnUrlExpiry: 2,
+    MaxRetry: 3,
+    MaxRetryOnTokenExpiry: 2,
+    MaxWebWorker: 20,
+    LimitFile: 200,
+    TaskCurrently: 10,
+    MaxFileInChunk: 2000,
+}
+
+export const ConfigBase = {
+    PageSize: 1000
+}

package/src/utils/Enum.ts

@@ -0,0 +1,29 @@
+export enum StatusWorker {
+    Success = "Success",
+    Error = "Error"
+}
+
+export enum StatusTranslate {
+    InQueue,
+    Translating,
+    Translated,
+    TranslateError,
+    Canceled,
+    NotFound
+}
+
+export enum Scope {
+    DataRead,
+    DataWrite,
+    DataCreate,
+    DataSearch,
+    BucketCreate,
+    BucketRead,
+    BucketUpdate,
+    BucketDelete,
+    CodeAll,
+    AccountRead,
+    AccountWrite,
+    UserProfileRead,
+    ViewablesRead
+}

package/src/utils/Helper.ts

@@ -0,0 +1,57 @@
+import { Buffer } from "buffer";
+
+export const validString = (value?: string): boolean => {
+  if (value === null || value === undefined || value === "") {
+    return false;
+  }
+
+  return true;
+};
+
+// large file is not supported (> 2GB)
+// export const readFileDataAsBase64 = async (file: File): Promise<Buffer> => {
+//   const chunkSize = 1024 * 1024 * 10; // 10 MB chunks
+//   const totalSize = file.size;
+//   let bytesRead = 0;
+
+//   const reader = file.stream().getReader(); // Create a ReadableStream reader
+
+//   // Create a buffer to store the file data incrementally
+//   const arrayBuffer = new Uint8Array(totalSize);
+
+//   while (true) {
+//     const { done, value } = await reader.read(); // Read a chunk
+//     if (done) break;
+
+//     // Copy the chunk into the ArrayBuffer
+//     arrayBuffer.set(value, bytesRead);
+//     bytesRead += value.byteLength;
+//   }
+//   return Buffer.from(arrayBuffer);
+// };
+export const readFileDataAsBase64 = (file: File): Promise<Buffer> => {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+
+    reader.onload = (event: any) => {
+      const buffer = Buffer.from(event.target.result);
+      resolve(buffer);
+    };
+
+    reader.onerror = (err: any) => {
+      console.error("error when read file", err);
+      reject(err);
+    };
+
+    reader.readAsArrayBuffer(file);
+  });
+};
+export const chunkArray = <T>(array: T[], max: number): T[][] => {
+  if (max <= 0) throw new Error("max must be a positive number");
+
+  const result: T[][] = [];
+  for (let i = 0; i < array.length; i += max) {
+    result.push(array.slice(i, i + max));
+  }
+  return result;
+};

package/src/workerDownloadSingleFile.ts

@@ -0,0 +1,34 @@
+import { ServiceIntegration } from "./ServiceIntegration";
+import { StatusWorker } from "./utils/Enum";
+// tạm thời chưa làm phần token
+self.onmessage = async (message) => {
+  const { data } = message;
+  try {
+    const chunk = await downloadSingleFile(data);
+    const result = {
+      status: StatusWorker.Success,
+      chunk: chunk,
+      requestId: data.requestId,
+      index: data.index,
+    };
+    self.postMessage(result, [chunk]); // Send the result back to the main thread
+  } catch (error) {
+    const result = {
+      status: StatusWorker.Error,
+      requestId: data.requestId,
+    };
+    self.postMessage(result);
+  }
+};
+
+async function downloadSingleFile(data: any) {
+  const { url, start, end } = data;
+  try {
+    const service = new ServiceIntegration();
+    const response = await service.fetchChunkFile(url, start, end);
+      return response;
+  } catch (error) {
+    console.error(`Error when download single file: ${error}`);
+    throw error;
+  }
+}

package/src/workerUploadChildFile.ts

@@ -0,0 +1,85 @@
+import { ApiStatus } from "./utils/Constants";
+import { Buffer } from "buffer";
+import { StatusWorker } from "./utils/Enum";
+
+let abortController: AbortController | null = null;
+let workerPortRoot: MessagePort | null = null;
+
+self.onmessage = async (message) => {
+  const { data } = message;
+  if (data.port) {
+    workerPortRoot = data.port;
+  } else {
+    // Handle abort message
+    if (data.type === "abort") {
+      if (abortController) {
+        abortController.abort();
+        abortController = null;
+      }
+      return;
+    }
+
+    try {
+      const responseUpload = await uploadChildFile(data);
+      const result = {
+        status: StatusWorker.Success,
+        responseUpload,
+        requestId: data.requestId,
+        contentLength: data.arrayBuffer.byteLength,
+      };
+      self.postMessage(result); // Send the result back to the main thread
+      if (workerPortRoot) {
+        workerPortRoot.postMessage({
+          type: "progressUpload",
+          progress: {
+            dataUploadId: data.dataUploadId,
+            percentCompleted: 0,
+            fileKey: data.fileName,
+            contentLength: data.arrayBuffer.byteLength,
+          },
+        });
+      }
+    } catch (error) {
+      const result = {
+        status: StatusWorker.Error,
+        requestId: data.requestId,
+        error: error instanceof Error ? error.message : String(error),
+      };
+      self.postMessage(result);
+    }
+  }
+};
+
+async function uploadChildFile(data: any) {
+  const { currentPresignUrl, arrayBuffer, partNumber } = data;
+  const buffer = Buffer.from(arrayBuffer);
+
+  // Create new AbortController for this request
+  abortController = new AbortController();
+
+  try {
+    const response = await fetch(currentPresignUrl.url, {
+      method: "PUT",
+      headers: currentPresignUrl.headers,
+      body: buffer,
+      signal: abortController.signal,
+    });
+    if (response.status === ApiStatus.Success) {
+      var eTag = response.headers.get("ETag");
+      if (eTag) {
+        const result = {
+          eTag: eTag.replace(/^"|"$/g, ""),
+          partNumber: partNumber,
+        };
+        return result;
+      }
+    }
+    throw new Error(`Error when upload child file: ${response.statusText}`);
+  } catch (error) {
+    if (error instanceof Error && error.name === "AbortError") {
+      throw new Error("Upload cancelled");
+    }
+    console.error(`Error when upload child file: ${error}`);
+    throw new Error(`Error when upload child file: ${error}`);
+  }
+}