dpu-cloud-sdk 1.0.0

package/dist/models/ResponseModel.d.ts

@@ -0,0 +1,99 @@
+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/dist/models/ResponseModel.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/Config.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Global configuration for DPU Storage
+ * This allows external packages to customize the BaseURL for their domains
+ */
+interface IConfig {
+    baseURL: string;
+}
+declare class DPUConfig {
+    private static instance;
+    private config;
+    private constructor();
+    static getInstance(): DPUConfig;
+    /**
+     * Set the base URL for API requests
+     * @param baseURL The base URL for all API calls
+     */
+    setBaseURL(baseURL: string): void;
+    /**
+     * Get the current base URL
+     */
+    getBaseURL(): string;
+    /**
+     * Set multiple configuration values at once
+     */
+    setConfig(config: Partial<IConfig>): void;
+    /**
+     * Get the entire configuration object
+     */
+    getConfig(): IConfig;
+}
+export declare const dpuConfig: DPUConfig;
+export {};

package/dist/utils/Config.js

@@ -0,0 +1,44 @@
+class DPUConfig {
+    static instance;
+    config = {
+        baseURL: 'https://translateservicedev.corebim.com', // Default URL
+    };
+    constructor() { }
+    static getInstance() {
+        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
+     */
+    setBaseURL(baseURL) {
+        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
+     */
+    getBaseURL() {
+        return this.config.baseURL;
+    }
+    /**
+     * Set multiple configuration values at once
+     */
+    setConfig(config) {
+        if (config.baseURL) {
+            this.setBaseURL(config.baseURL);
+        }
+    }
+    /**
+     * Get the entire configuration object
+     */
+    getConfig() {
+        return { ...this.config };
+    }
+}
+export const dpuConfig = DPUConfig.getInstance();

package/dist/utils/Constants.d.ts

@@ -0,0 +1,48 @@
+export declare const Path: {
+    readonly BaseURL: string;
+    InitiateMultipartUpload: string;
+    GeneratePresignedUrls: string;
+    GeneratePresignedUrl: string;
+    GenerateMultiPresignedURL: string;
+    CompleteMultipartUpload: string;
+    AbortMultipartUpload: string;
+    GetObjectDetail: string;
+    GetObjects: string;
+    GetUrlDownload: string;
+    ApplyPermissionToObjects: string;
+};
+export declare const PathManagement: {
+    CompressFolder: string;
+    GetStatusCompress: string;
+    CancelDownload: string;
+    TranslateFile: string;
+    GetStatusTranslate: string;
+    GetStatusTranslateFile: string;
+    GetEPSGRegionCode: string;
+    GetFileTileSet: string;
+};
+export declare const PathAuth: {
+    GetToken: string;
+};
+export declare const ApiStatus: {
+    Success: number;
+    BadRequest: number;
+    Unauthorized: number;
+    Forbidden: number;
+    NotFound: number;
+    InternalServerError: number;
+};
+export declare const ConfigFileRules: {
+    ChunkSize: number;
+    MaxChunkCountAllowed: number;
+    MaxRetryOnUrlExpiry: number;
+    MaxRetry: number;
+    MaxRetryOnTokenExpiry: number;
+    MaxWebWorker: number;
+    LimitFile: number;
+    TaskCurrently: number;
+    MaxFileInChunk: number;
+};
+export declare const ConfigBase: {
+    PageSize: number;
+};

package/dist/utils/Constants.js

@@ -0,0 +1,55 @@
+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/dist/utils/Enum.d.ts

@@ -0,0 +1,27 @@
+export declare enum StatusWorker {
+    Success = "Success",
+    Error = "Error"
+}
+export declare enum StatusTranslate {
+    InQueue = 0,
+    Translating = 1,
+    Translated = 2,
+    TranslateError = 3,
+    Canceled = 4,
+    NotFound = 5
+}
+export declare enum Scope {
+    DataRead = 0,
+    DataWrite = 1,
+    DataCreate = 2,
+    DataSearch = 3,
+    BucketCreate = 4,
+    BucketRead = 5,
+    BucketUpdate = 6,
+    BucketDelete = 7,
+    CodeAll = 8,
+    AccountRead = 9,
+    AccountWrite = 10,
+    UserProfileRead = 11,
+    ViewablesRead = 12
+}

package/dist/utils/Enum.js

@@ -0,0 +1,30 @@
+export var StatusWorker;
+(function (StatusWorker) {
+    StatusWorker["Success"] = "Success";
+    StatusWorker["Error"] = "Error";
+})(StatusWorker || (StatusWorker = {}));
+export var StatusTranslate;
+(function (StatusTranslate) {
+    StatusTranslate[StatusTranslate["InQueue"] = 0] = "InQueue";
+    StatusTranslate[StatusTranslate["Translating"] = 1] = "Translating";
+    StatusTranslate[StatusTranslate["Translated"] = 2] = "Translated";
+    StatusTranslate[StatusTranslate["TranslateError"] = 3] = "TranslateError";
+    StatusTranslate[StatusTranslate["Canceled"] = 4] = "Canceled";
+    StatusTranslate[StatusTranslate["NotFound"] = 5] = "NotFound";
+})(StatusTranslate || (StatusTranslate = {}));
+export var Scope;
+(function (Scope) {
+    Scope[Scope["DataRead"] = 0] = "DataRead";
+    Scope[Scope["DataWrite"] = 1] = "DataWrite";
+    Scope[Scope["DataCreate"] = 2] = "DataCreate";
+    Scope[Scope["DataSearch"] = 3] = "DataSearch";
+    Scope[Scope["BucketCreate"] = 4] = "BucketCreate";
+    Scope[Scope["BucketRead"] = 5] = "BucketRead";
+    Scope[Scope["BucketUpdate"] = 6] = "BucketUpdate";
+    Scope[Scope["BucketDelete"] = 7] = "BucketDelete";
+    Scope[Scope["CodeAll"] = 8] = "CodeAll";
+    Scope[Scope["AccountRead"] = 9] = "AccountRead";
+    Scope[Scope["AccountWrite"] = 10] = "AccountWrite";
+    Scope[Scope["UserProfileRead"] = 11] = "UserProfileRead";
+    Scope[Scope["ViewablesRead"] = 12] = "ViewablesRead";
+})(Scope || (Scope = {}));

package/dist/utils/Helper.d.ts

@@ -0,0 +1,4 @@
+import { Buffer } from "buffer";
+export declare const validString: (value?: string) => boolean;
+export declare const readFileDataAsBase64: (file: File) => Promise<Buffer>;
+export declare const chunkArray: <T>(array: T[], max: number) => T[][];

package/dist/utils/Helper.js

@@ -0,0 +1,47 @@
+import { Buffer } from "buffer";
+export const validString = (value) => {
+    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) => {
+    return new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.onload = (event) => {
+            const buffer = Buffer.from(event.target.result);
+            resolve(buffer);
+        };
+        reader.onerror = (err) => {
+            console.error("error when read file", err);
+            reject(err);
+        };
+        reader.readAsArrayBuffer(file);
+    });
+};
+export const chunkArray = (array, max) => {
+    if (max <= 0)
+        throw new Error("max must be a positive number");
+    const result = [];
+    for (let i = 0; i < array.length; i += max) {
+        result.push(array.slice(i, i + max));
+    }
+    return result;
+};

package/dist/workerDownloadSingleFile.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/workerDownloadSingleFile.js

@@ -0,0 +1,35 @@
+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) {
+    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/dist/workerUploadChildFile.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/workerUploadChildFile.js

@@ -0,0 +1,82 @@
+import { ApiStatus } from "./utils/Constants";
+import { Buffer } from "buffer";
+import { StatusWorker } from "./utils/Enum";
+let abortController = null;
+let workerPortRoot = 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) {
+    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}`);
+    }
+}

package/dist/workerUploadSingleFile.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/workerUploadSingleFile.js

@@ -0,0 +1,93 @@
+import { ConfigFileRules } from "./utils/Constants";
+import { Buffer } from "buffer";
+import { StatusWorker } from "./utils/Enum";
+import { ServiceIntegration } from "./ServiceIntegration";
+let abortController = null;
+let workerPortRoot = null;
+// tạm thời chưa làm phần token
+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;
+            }
+            const result = {
+                status: StatusWorker.Error,
+                requestId: data.requestId,
+                error: "Upload cancelled",
+            };
+            self.postMessage(result);
+            return;
+        }
+        try {
+            // Create new AbortController for this request
+            abortController = new AbortController();
+            const responseUpload = await uploadSingleFile(data);
+            const result = {
+                status: StatusWorker.Success,
+                responseUpload,
+                requestId: data.requestId,
+                workerId: data.workerId,
+                fileName: data.fullName,
+                fileKey: data.fileKey,
+            };
+            // Clear arrayBuffer after successful upload
+            data.arrayBuffer = null;
+            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.fileKey,
+                        versionFile: responseUpload.versionFile,
+                        contentLength: responseUpload.contentLength,
+                    },
+                });
+            }
+        }
+        catch (error) {
+            const result = {
+                status: StatusWorker.Error,
+                requestId: data.requestId,
+                workerId: data.workerId,
+                fileName: data.fullName,
+                fileKey: data.fileKey,
+                error: error instanceof Error ? error.message : String(error),
+            };
+            self.postMessage(result);
+        }
+        finally {
+            abortController = null;
+        }
+    }
+};
+async function uploadSingleFile(data) {
+    const { bucketName, file, fullName, accessToken, initUpload, isGetInfo, preSignUrl, arrayBuffer, } = data;
+    const buffer = Buffer.from(arrayBuffer);
+    try {
+        const service = new ServiceIntegration();
+        if (buffer.length > ConfigFileRules.ChunkSize) {
+            const response = await service.uploadLargeFile(bucketName, fullName, buffer, accessToken, abortController ?? new AbortController(), undefined, undefined, initUpload, isGetInfo);
+            return response;
+        }
+        else {
+            const response = await service.uploadSmallFile(bucketName, fullName, buffer, accessToken, abortController ?? new AbortController(), undefined, undefined, isGetInfo, preSignUrl);
+            return response;
+        }
+    }
+    catch (error) {
+        if (error instanceof Error && error.name === "AbortError") {
+            throw new Error("Upload cancelled");
+        }
+        console.error(`Error when upload single file: ${error}`);
+        throw error;
+    }
+}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "dpu-cloud-sdk",
+  "version": "1.0.0",
+  "main": "dist/index",
+  "types": "dist/index",
+  "scripts": {
+    "version-patch": "npm version patch",
+    "build": "tsc",
+    "bump-build": "npm run version-patch && npm run build",
+    "bump-build-pack": "npm run bump-build && npm pack",
+    "bump-build-publish": "npm run bump-build && npm publish",
+    "dev": "webpack --mode development --watch",
+    "clean": "rimraf dist/*",
+    "webpack": "npx webpack --config webpack.config.js --mode=production ",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "description": "",
+  "dependencies": {
+    "@types/node": "^22.5.0",
+    "buffer": "^6.0.3",
+    "cross-env": "^7.0.3",
+    "dotenv": "^16.4.5",
+    "p-limit": "^6.1.0",
+    "rimraf": "^6.0.1",
+    "typescript": "^5.5.4"
+  },
+  "devDependencies": {
+    "webpack-cli": "^5.1.4"
+  }
+}