@prmichaelsen/firebase-admin-sdk-v8 2.2.2 → 2.3.0

package/dist/index.mjs

@@ -1124,7 +1124,7 @@ function getDefaultBucket() {
     return customBucket;
   }
   const projectId = getProjectId();
-  return `${projectId}.appspot.com`;
+  return `${projectId}.firebasestorage.app`;
 }
 function detectContentType(filename) {
   const ext = filename.split(".").pop()?.toLowerCase();
@@ -1423,6 +1423,204 @@ async function generateSignedUrl(path, options) {
   const signedUrl = `https://storage.googleapis.com${canonicalUri}?${canonicalQueryString}&X-Goog-Signature=${signature}`;
   return signedUrl;
 }
+
+// src/storage/resumable-upload.ts
+var UPLOAD_API_BASE2 = "https://storage.googleapis.com/upload/storage/v1";
+function getDefaultBucket2() {
+  const customBucket = process.env.FIREBASE_STORAGE_BUCKET;
+  if (customBucket) {
+    return customBucket;
+  }
+  const projectId = getProjectId();
+  return `${projectId}.firebasestorage.app`;
+}
+async function initiateResumableUpload(bucket, path, contentType, totalSize, metadata) {
+  const token = await getAdminAccessToken();
+  const url = `${UPLOAD_API_BASE2}/b/${encodeURIComponent(bucket)}/o?uploadType=resumable&name=${encodeURIComponent(path)}`;
+  const requestBody = {};
+  if (metadata) {
+    requestBody.metadata = metadata;
+  }
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      "Authorization": `Bearer ${token}`,
+      "Content-Type": "application/json",
+      "X-Upload-Content-Type": contentType,
+      "X-Upload-Content-Length": totalSize.toString()
+    },
+    body: Object.keys(requestBody).length > 0 ? JSON.stringify(requestBody) : void 0
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`Failed to initiate resumable upload: ${response.status} ${errorText}`);
+  }
+  const sessionUri = response.headers.get("Location");
+  if (!sessionUri) {
+    throw new Error("No session URI returned from resumable upload initiation");
+  }
+  return sessionUri;
+}
+async function uploadChunk(sessionUri, chunk, start, total) {
+  const end = start + chunk.byteLength - 1;
+  const response = await fetch(sessionUri, {
+    method: "PUT",
+    headers: {
+      "Content-Length": chunk.byteLength.toString(),
+      "Content-Range": `bytes ${start}-${end}/${total}`
+    },
+    body: chunk
+  });
+  if (response.status === 200 || response.status === 201) {
+    const metadata = await response.json();
+    return { complete: true, metadata };
+  } else if (response.status === 308) {
+    return { complete: false };
+  } else {
+    const errorText = await response.text();
+    throw new Error(`Chunk upload failed: ${response.status} ${errorText}`);
+  }
+}
+async function getUploadProgress(sessionUri) {
+  const response = await fetch(sessionUri, {
+    method: "PUT",
+    headers: {
+      "Content-Length": "0",
+      "Content-Range": "bytes */*"
+    }
+  });
+  if (response.status === 308) {
+    const range = response.headers.get("Range");
+    if (range) {
+      const match = range.match(/bytes=0-(\d+)/);
+      if (match) {
+        return parseInt(match[1], 10) + 1;
+      }
+    }
+  } else if (response.status === 200 || response.status === 201) {
+    const metadata = await response.json();
+    return parseInt(metadata.size, 10);
+  }
+  return 0;
+}
+async function toArrayBuffer(data) {
+  if (data instanceof ArrayBuffer) {
+    return data;
+  } else if (data instanceof Uint8Array) {
+    const buffer = new ArrayBuffer(data.byteLength);
+    new Uint8Array(buffer).set(data);
+    return buffer;
+  } else if (data instanceof Blob) {
+    return await data.arrayBuffer();
+  }
+  throw new Error("Unsupported data type");
+}
+async function readChunkFromStream(reader, chunkSize) {
+  const chunks = [];
+  let totalBytes = 0;
+  while (totalBytes < chunkSize) {
+    const { value, done } = await reader.read();
+    if (done) {
+      if (totalBytes === 0) {
+        return { chunk: null, done: true };
+      }
+      break;
+    }
+    if (value) {
+      chunks.push(value);
+      totalBytes += value.byteLength;
+      if (totalBytes >= chunkSize) {
+        break;
+      }
+    }
+  }
+  const combined = new Uint8Array(totalBytes);
+  let offset = 0;
+  for (const chunk of chunks) {
+    combined.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return { chunk: combined.buffer, done: false };
+}
+async function uploadFileResumable(path, data, contentType, options = {}) {
+  const bucket = getDefaultBucket2();
+  const chunkSize = options.chunkSize || 256 * 1024;
+  if (data instanceof ReadableStream) {
+    return await uploadFromStream(bucket, path, data, contentType, chunkSize, options);
+  }
+  const buffer = await toArrayBuffer(data);
+  const total = buffer.byteLength;
+  let sessionUri = options.resumeToken;
+  let uploaded = 0;
+  if (!sessionUri) {
+    sessionUri = await initiateResumableUpload(
+      bucket,
+      path,
+      contentType,
+      total,
+      options.metadata
+    );
+  } else {
+    uploaded = await getUploadProgress(sessionUri);
+    if (options.onProgress) {
+      options.onProgress(uploaded, total);
+    }
+  }
+  while (uploaded < total) {
+    const end = Math.min(uploaded + chunkSize, total);
+    const chunk = buffer.slice(uploaded, end);
+    const result = await uploadChunk(sessionUri, chunk, uploaded, total);
+    uploaded = end;
+    if (options.onProgress) {
+      options.onProgress(uploaded, total);
+    }
+    if (result.complete) {
+      return result.metadata;
+    }
+  }
+  throw new Error("Upload incomplete - all chunks sent but no completion response");
+}
+async function uploadFromStream(bucket, path, stream, contentType, chunkSize, options) {
+  const total = options.totalSize || -1;
+  if (total === -1) {
+    throw new Error("totalSize is required when uploading from ReadableStream");
+  }
+  const sessionUri = await initiateResumableUpload(
+    bucket,
+    path,
+    contentType,
+    total,
+    options.metadata
+  );
+  const reader = stream.getReader();
+  let uploaded = 0;
+  let lastResult = null;
+  try {
+    while (true) {
+      const { chunk, done } = await readChunkFromStream(reader, chunkSize);
+      if (done || !chunk) {
+        if (lastResult && lastResult.complete) {
+          return lastResult.metadata;
+        }
+        if (uploaded === total && lastResult) {
+          return lastResult.metadata;
+        }
+        break;
+      }
+      lastResult = await uploadChunk(sessionUri, chunk, uploaded, total);
+      uploaded += chunk.byteLength;
+      if (options.onProgress) {
+        options.onProgress(uploaded, total);
+      }
+      if (lastResult.complete) {
+        return lastResult.metadata;
+      }
+    }
+    throw new Error("Stream ended but upload not complete");
+  } finally {
+    reader.releaseLock();
+  }
+}
 export {
   FieldValue,
   addDocument,
@@ -1453,5 +1651,6 @@ export {
   signInWithCustomToken,
   updateDocument,
   uploadFile,
+  uploadFileResumable,
   verifyIdToken
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prmichaelsen/firebase-admin-sdk-v8",
-  "version": "2.2.2",
+  "version": "2.3.0",
   "description": "Firebase Admin SDK for Cloudflare Workers and edge runtimes using REST APIs",
   "main": "dist/index.js",
   "module": "dist/index.mjs",