@lacrous/omnicloud 0.2.32 → 0.2.33

package/dist/index.cjs

@@ -77,6 +77,51 @@ var OmniCloudError = class extends Error {
   details;
 };
 var DEFAULT_RETRY = { attempts: 3, baseDelayMs: 300 };
+function randomId() {
+  return globalThis.crypto.randomUUID().replace(/-/g, "");
+}
+function multipartHead(boundary, fields, fileName) {
+  const parts = fields.map(
+    ([name, value]) => `--${boundary}\r
+Content-Disposition: form-data; name="${name}"\r
+\r
+${value}\r
+`
+  );
+  const safeName = fileName.replace(/["\\\r\n]/g, "_");
+  parts.push(
+    `--${boundary}\r
+Content-Disposition: form-data; name="file"; filename="${safeName}"\r
+Content-Type: application/octet-stream\r
+\r
+`
+  );
+  return parts.join("");
+}
+function nodeMultipartStream(head, file, tail) {
+  const encoder = new TextEncoder();
+  const iterator = file[Symbol.asyncIterator]();
+  let sentHead = false;
+  return new ReadableStream({
+    async pull(controller) {
+      if (!sentHead) {
+        sentHead = true;
+        controller.enqueue(encoder.encode(head));
+        return;
+      }
+      const { done, value } = await iterator.next();
+      if (done) {
+        controller.enqueue(encoder.encode(tail));
+        controller.close();
+        return;
+      }
+      controller.enqueue(typeof value === "string" ? encoder.encode(value) : new Uint8Array(value));
+    },
+    async cancel(reason) {
+      await iterator.return?.(reason);
+    }
+  });
+}
 function sleep(ms, signal) {
   return new Promise((resolve, reject) => {
     const timer = setTimeout(resolve, ms);
@@ -368,10 +413,13 @@ var FilesApi = class {
   async upload(input, options = {}) {
     const attempts = Math.max(1, (options.retry ?? 2) + 1);
     let lastError;
-    const blob = await toBlob(input);
+    const source = input.path !== void 0 && this.canStreamFromDisk() ? { kind: "path", path: input.path } : { kind: "blob", blob: await toBlob(input) };
     for (let attempt = 1; attempt <= attempts; attempt += 1) {
       try {
-        return await this.uploadOnce(blob, input.name, options);
+        if (source.kind === "path") {
+          return await this.uploadPathOnce(source.path, input.name, options);
+        }
+        return await this.uploadOnce(source.blob, input.name, options);
       } catch (error) {
         lastError = error;
         if (options.signal?.aborted) throw error;
@@ -381,6 +429,46 @@ var FilesApi = class {
     }
     throw lastError;
   }
+  canStreamFromDisk() {
+    return typeof XMLHttpRequest !== "function" && typeof ReadableStream === "function";
+  }
+  /**
+   * Node: streams a file from disk as a multipart body. The file is re-opened on
+   * every attempt, so a retry sends the same bytes without holding them in memory.
+   */
+  async uploadPathOnce(path, name, options) {
+    const { createReadStream, statSync } = await import("fs");
+    const size = statSync(path).size;
+    const boundary = `omnicloud-${randomId()}`;
+    const fields = [];
+    if (options.folderId) fields.push(["folderId", options.folderId]);
+    const head = multipartHead(boundary, fields, name);
+    const tail = `\r
+--${boundary}--\r
+`;
+    const body = nodeMultipartStream(head, createReadStream(path), tail);
+    const response = await this.client.fetchImpl(`${this.client.baseUrl}/api/files`, {
+      method: "POST",
+      headers: {
+        ...this.client.defaultHeaders,
+        "Content-Type": `multipart/form-data; boundary=${boundary}`,
+        "Content-Length": String(Buffer.byteLength(head) + size + Buffer.byteLength(tail))
+      },
+      body,
+      credentials: "include",
+      duplex: "half"
+    });
+    const text = await response.text();
+    if (!response.ok) {
+      const error = safeJsonParse(text)?.error;
+      throw new OmniCloudError(
+        response.status,
+        error?.code ?? "UPLOAD_FAILED",
+        error?.message ?? `Upload failed (${response.status})`
+      );
+    }
+    return JSON.parse(text).file;
+  }
   async uploadOnce(blob, name, options) {
     const form = new FormData();
     form.append("file", blob, name);