hydrousdb 3.5.3 → 3.5.5

package/dist/index.d.cts

@@ -278,6 +278,7 @@ interface UploadOptions {
     overwrite?: boolean;
     mimeType?: string;
     expiresInSeconds?: number;
+    onProgress?: (percent: number) => void;
 }
 interface UploadResult {
     path: string;

package/dist/index.d.ts

@@ -278,6 +278,7 @@ interface UploadOptions {
     overwrite?: boolean;
     mimeType?: string;
     expiresInSeconds?: number;
+    onProgress?: (percent: number) => void;
 }
 interface UploadResult {
     path: string;

package/dist/index.mjs

@@ -149,19 +149,77 @@ var HttpClient = class {
    * Uses XHR in browsers for onprogress support; fetch in Node.
    */
   async putToSignedUrl(signedUrl, data, mimeType, onProgress) {
-    const body = data instanceof Blob ? data : data instanceof Uint8Array ? data.buffer : data;
-    if (typeof XMLHttpRequest !== "undefined" && typeof onProgress === "function") {
+    const body = data;
+    if (typeof XMLHttpRequest !== "undefined") {
       await new Promise((resolve, reject) => {
         const xhr = new XMLHttpRequest();
-        xhr.upload.onprogress = (e) => {
-          if (e.lengthComputable) onProgress(Math.round(e.loaded / e.total * 100));
-        };
+        if (typeof onProgress === "function") {
+          xhr.upload.onprogress = (e) => {
+            if (e.lengthComputable) onProgress(Math.round(e.loaded / e.total * 100));
+          };
+        }
         xhr.onload = () => xhr.status >= 200 && xhr.status < 300 ? resolve() : reject(new Error(`GCS upload failed: ${xhr.status}`));
         xhr.onerror = () => reject(new Error("GCS upload network error"));
         xhr.open("PUT", signedUrl);
         xhr.setRequestHeader("Content-Type", mimeType);
         xhr.send(body);
       });
+    } else if (typeof process !== "undefined" && process.versions && process.versions.node) {
+      const https = await import('https');
+      const { URL } = await import('url');
+      let buffer;
+      if (typeof Buffer !== "undefined" && Buffer.isBuffer(body)) {
+        buffer = body;
+      } else if (body instanceof ArrayBuffer) {
+        buffer = Buffer.from(body);
+      } else if (body instanceof Uint8Array) {
+        buffer = Buffer.from(body.buffer, body.byteOffset, body.byteLength);
+      } else if (typeof Blob !== "undefined" && body instanceof Blob) {
+        const arrayBuffer = await body.arrayBuffer();
+        buffer = Buffer.from(arrayBuffer);
+      } else {
+        buffer = Buffer.from(String(body));
+      }
+      const urlObj = new URL(signedUrl);
+      const options = {
+        method: "PUT",
+        hostname: urlObj.hostname,
+        path: urlObj.pathname + urlObj.search,
+        headers: {
+          "Content-Type": mimeType,
+          "Content-Length": String(buffer.length)
+        }
+      };
+      await new Promise((resolve, reject) => {
+        const req = https.request(options, (res) => {
+          if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
+            resolve();
+          } else {
+            reject(new Error(`GCS upload failed: ${res.statusCode}`));
+          }
+        });
+        req.on("error", (err) => {
+          reject(err);
+        });
+        const totalBytes = buffer.length;
+        let writtenBytes = 0;
+        const chunkSize = 64 * 1024;
+        const writeChunk = () => {
+          if (writtenBytes < totalBytes) {
+            const nextChunkSize = Math.min(chunkSize, totalBytes - writtenBytes);
+            const chunk = buffer.subarray(writtenBytes, writtenBytes + nextChunkSize);
+            req.write(chunk);
+            writtenBytes += nextChunkSize;
+            if (typeof onProgress === "function") {
+              onProgress(Math.round(writtenBytes / totalBytes * 100));
+            }
+            setImmediate(writeChunk);
+          } else {
+            req.end();
+          }
+        };
+        writeChunk();
+      });
     } else {
       const res = await fetch(signedUrl, {
         method: "PUT",
@@ -1061,8 +1119,32 @@ var StorageManager = class {
    * ```
    */
   async upload(data, path, options = {}) {
-    const { isPublic = false, overwrite = false, mimeType } = options;
+    const { isPublic = false, overwrite = false, mimeType, onProgress } = options;
     const mime = mimeType ?? guessMimeType(path);
+    let size = 0;
+    if (data instanceof Blob) {
+      size = data.size;
+    } else if (data instanceof Uint8Array || data instanceof ArrayBuffer) {
+      size = data.byteLength;
+    } else if (typeof Buffer !== "undefined" && Buffer.isBuffer(data)) {
+      size = data.length;
+    }
+    const useDirectUpload = onProgress !== void 0 || size > 5 * 1024 * 1024;
+    if (useDirectUpload) {
+      const { uploadUrl, path: cleanPath } = await this.getUploadUrl({
+        path,
+        mimeType: mime,
+        size,
+        isPublic,
+        overwrite
+      });
+      await this.uploadToSignedUrl(uploadUrl, data, mime, onProgress);
+      return this.confirmUpload({
+        path: cleanPath,
+        mimeType: mime,
+        isPublic
+      });
+    }
     const formData = new FormData();
     const blob = data instanceof Blob ? data : new Blob([data], { type: mime });
     formData.append("file", blob, path.split("/").pop() ?? "file");