npm - hydrousdb - Versions diffs - 3.5.3 → 3.5.5 - Mend

hydrousdb 3.5.3 → 3.5.5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (8) hide show

package/README.md CHANGED Viewed

@@ -706,7 +706,7 @@ await storage.uploadRaw('<html>…</html>', 'pages/home.html', { mimeType: 'text
 ### Large Files with Progress
-Recommended for files > 10 MB or when you need a progress indicator (browsers only).
+Recommended for files > 10 MB or when you need a progress indicator (supported in both browser and Node.js environments).
 ```ts
 // Step 1 — get a signed GCS PUT URL
@@ -719,7 +719,7 @@ const { uploadUrl, path, expiresAt, expiresIn } = await storage.getUploadUrl({
   expiresInSeconds: 3600, // URL lifetime
 });
-// Step 2 — upload directly to GCS with progress callback (browser XHR)
+// Step 2 — upload directly to GCS with progress callback (browser & Node.js)
 await storage.uploadToSignedUrl(uploadUrl, file, 'video/mp4', (percent) => {
   console.log(`${percent}% uploaded`);
 });
@@ -798,7 +798,7 @@ for (const err of failed) {
 ---
-### List, Metadata & Signed URLs
+### List & Metadata
 ```ts
 // List files and folders (paginated)
@@ -817,12 +817,24 @@ if (hasMore) {
 // Get file metadata
 const meta = await storage.getMetadata('avatars/alice.jpg');
 // → { path, size, mimeType, isPublic, publicUrl, downloadUrl, createdAt, updatedAt }
+```
+---
+### Temporary Sharing (Signed URLs)
-// Generate a time-limited link — anyone with the URL can download (no key needed)
+Generate time-limited download URLs for temporary, unauthenticated sharing of private files. Anyone with the URL can access and download the file directly from Google Cloud Storage without needing an `X-Storage-Key` header.
+*Note: Downloads via signed URLs bypass the Hydrous server entirely (client direct to GCS), meaning download statistics and monthly bandwidth quotas will not be tracked on the server for these requests.*
+```ts
 const { signedUrl, expiresAt, expiresIn } = await storage.getSignedUrl(
   'private/report.pdf',
-  3600, // lifetime in seconds (default: 3600)
+  3600, // URL lifetime in seconds (default: 3600 = 1 hour, max: 604800 = 7 days)
 );
+console.log(signedUrl); // Direct GCS download URL
+console.log(expiresAt); // ISO timestamp of when the link expires
 ```
 ---

package/dist/index.cjs CHANGED Viewed

@@ -151,19 +151,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",
@@ -1063,8 +1121,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");