@useupup/core 3.3.0

package/dist/chunk-MHYXDLZR.js

@@ -0,0 +1,569 @@
+import { fileFingerprint, loadSession, removeSession, updateSessionToken, updateSessionProgress, saveSession } from './chunk-OOPDEOTM.js';
+import { uploadErrorFromResponse, UpupConfigError, UpupNetworkError, UpupError, UpupStorageError } from './chunk-GE4LIVXP.js';
+
+// src/strategies/server-credentials.ts
+function operationForPath(path) {
+  if (path.startsWith("/presign")) return "presign";
+  if (path.startsWith("/multipart/init")) return "multipart-init";
+  if (path.startsWith("/multipart/sign-part")) return "multipart-sign-part";
+  if (path.startsWith("/multipart/complete")) return "multipart-complete";
+  if (path.startsWith("/multipart/abort")) return "multipart-abort";
+  if (path.startsWith("/multipart/resume")) return "multipart-resume";
+  return "upload";
+}
+var ServerCredentials = class {
+  constructor(options) {
+    this.serverUrl = options.serverUrl.replace(/\/$/, "");
+    this.headers = {
+      "Content-Type": "application/json",
+      ...options.headers
+    };
+  }
+  async post(path, body) {
+    const response = await fetch(`${this.serverUrl}${path}`, {
+      method: "POST",
+      headers: this.headers,
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      const responseBody = await response.text().catch(() => "");
+      const err = uploadErrorFromResponse({
+        status: response.status,
+        statusText: response.statusText,
+        body: responseBody,
+        kind: "storage",
+        operation: operationForPath(path)
+      });
+      throw err;
+    }
+    return response.json();
+  }
+  async getPresignedUrl(file) {
+    return this.post("/presign", {
+      name: file.name,
+      size: file.size,
+      type: file.type,
+      metadata: file.metadata ?? {}
+    });
+  }
+  async initMultipartUpload(file) {
+    return this.post("/multipart/init", {
+      name: file.name,
+      size: file.size,
+      type: file.type,
+      metadata: file.metadata ?? {}
+    });
+  }
+  async signPart(params) {
+    return this.post(
+      "/multipart/sign-part",
+      params
+    );
+  }
+  async completeMultipartUpload(params) {
+    return this.post(
+      "/multipart/complete",
+      params
+    );
+  }
+  async abortMultipartUpload(params) {
+    await this.post("/multipart/abort", params);
+  }
+  /** Re-attach to an upload the client left in flight (page reload, pause,
+   *  retry) or whose token aged past its 1h TTL. The presented token is the
+   *  ONLY input — key/uploadId are never sent by the client — and the
+   *  response carries a freshly-signed replacement plus the parts storage
+   *  already holds, each with its byte size. */
+  async resumeMultipartUpload(params) {
+    return this.post("/multipart/resume", params);
+  }
+};
+
+// src/strategies/multipart-upload.ts
+var DEFAULT_CHUNK_SIZE = 5 * 1024 * 1024;
+var DEFAULT_MAX_CONCURRENT = 3;
+var DEFAULT_RETRY_DELAYS = [0, 1e3, 3e3, 5e3];
+var DEFAULT_PART_TIMEOUT_MS = 18e4;
+var MATERIALIZE_PART_MAX_BYTES = 16 * 1024 * 1024;
+var MAX_PARTS = 1e4;
+function isAborted(signal) {
+  return signal.aborted;
+}
+function isClientError(error) {
+  const status = error instanceof UpupError ? error.status : void 0;
+  return status !== void 0 && status >= 400 && status < 500;
+}
+function isExpiredTokenError(error) {
+  return error instanceof UpupError && error.status === 403 && error.code === "expired";
+}
+function isUnresumableFailure(error) {
+  return error instanceof UpupStorageError && (error.operation === "multipart-init" || error.operation === "multipart-complete") && isClientError(error);
+}
+function partStallError(partNumber, timeoutMs) {
+  return new UpupError(
+    `Part ${partNumber} stalled: no response within ${timeoutMs}ms`,
+    "TIMEOUT" /* TIMEOUT */,
+    true
+  );
+}
+function isRetryablePartFailure(error) {
+  if (error instanceof UpupError) {
+    return error.retryable || error.status === 429 || error.status !== void 0 && error.status >= 500;
+  }
+  if (error instanceof DOMException && error.name === "AbortError") {
+    return false;
+  }
+  return error instanceof TypeError;
+}
+function abortableDelay(ms, signal) {
+  return new Promise((resolve) => {
+    const wake = () => {
+      clearTimeout(timer);
+      signal.removeEventListener("abort", wake);
+      resolve();
+    };
+    const timer = setTimeout(wake, ms);
+    signal.addEventListener("abort", wake, { once: true });
+  });
+}
+function readContentHash(file) {
+  const metadata = file.metadata;
+  return typeof metadata?.originalContentHash === "string" ? metadata.originalContentHash : void 0;
+}
+function abortPersistedMultipartSessions(files, credentials) {
+  for (const file of files) {
+    if (!(file instanceof File)) continue;
+    try {
+      const fingerprint = fileFingerprint(file);
+      const session = loadSession(fingerprint);
+      if (!session) continue;
+      removeSession(fingerprint);
+      void credentials.abortMultipartUpload?.({ token: session.token }).catch(() => {
+      });
+    } catch {
+    }
+  }
+}
+var MultipartUpload = class {
+  constructor(options) {
+    const { credentials } = options;
+    if (!credentials.initMultipartUpload || !credentials.signPart || !credentials.completeMultipartUpload) {
+      throw new UpupConfigError(
+        "CredentialStrategy must implement multipart methods (initMultipartUpload, signPart, completeMultipartUpload)"
+      );
+    }
+    this.credentials = credentials;
+    this.initMultipartUpload = credentials.initMultipartUpload.bind(credentials);
+    this.signPart = credentials.signPart.bind(credentials);
+    this.completeMultipartUpload = credentials.completeMultipartUpload.bind(credentials);
+    this.resumeMultipartUpload = credentials.resumeMultipartUpload?.bind(credentials);
+    this.chunkSizeBytes = options.chunkSizeBytes ?? DEFAULT_CHUNK_SIZE;
+    const requestedConcurrency = Math.floor(
+      options.maxConcurrentParts ?? DEFAULT_MAX_CONCURRENT
+    );
+    this.maxConcurrentParts = Number.isFinite(requestedConcurrency) ? Math.max(1, requestedConcurrency) : DEFAULT_MAX_CONCURRENT;
+    this.persist = options.persist ?? false;
+    this.sessionScope = options.sessionScope;
+    this.retryDelays = options.retryDelays ?? DEFAULT_RETRY_DELAYS;
+    this.partTimeoutMs = options.partTimeoutMs ?? DEFAULT_PART_TIMEOUT_MS;
+  }
+  /**
+   * Each stored part must be byte-for-byte where this file's own chunking
+   * would put it: exactly `partSize`, except the file's TRUE final part
+   * (`partNumber === totalParts`), which must be exactly the remaining tail.
+   *
+   * The "highest part number we happen to hold" is NOT the exemption — the
+   * server may hold a sparse prefix (say parts 1, 2, 5 of 10), and letting
+   * part 5 be short would splice a short block into the MIDDLE of the object.
+   * S3 only enforces the ≥5 MiB floor on non-final parts, so it would accept
+   * the complete call and hand back a silently corrupt object. A part with no
+   * reported `size` is unverifiable and therefore equally unusable.
+   */
+  partsMatchSession(parts, partSize, fileSize) {
+    if (partSize <= 0) return false;
+    const totalParts = Math.ceil(fileSize / partSize);
+    const finalPartSize = fileSize - (totalParts - 1) * partSize;
+    return parts.every((part) => {
+      if (typeof part.size !== "number") return false;
+      if (part.partNumber < 1 || part.partNumber > totalParts) {
+        return false;
+      }
+      return part.partNumber === totalParts ? part.size === finalPartSize : part.size === partSize;
+    });
+  }
+  /**
+   * Try to re-attach to the upload a previous session left in flight.
+   * Returns `null` for every "just start fresh" outcome — a resume failure
+   * must never fail an upload that a fresh init could still serve.
+   */
+  async tryResume(fingerprint, fileSize, contentHash) {
+    const resume = this.resumeMultipartUpload;
+    if (!resume) return null;
+    const session = loadSession(fingerprint);
+    if (!session) return null;
+    if (session.scope !== this.sessionScope) {
+      removeSession(fingerprint);
+      return null;
+    }
+    if (contentHash !== void 0 && session.contentHash !== void 0 && session.contentHash !== contentHash) {
+      removeSession(fingerprint);
+      return null;
+    }
+    let response;
+    try {
+      response = await resume({ token: session.token });
+    } catch (error) {
+      if (isClientError(error)) removeSession(fingerprint);
+      return null;
+    }
+    const parts = [...response.parts].sort(
+      (a, b) => a.partNumber - b.partNumber
+    );
+    if (!this.partsMatchSession(parts, session.partSize, fileSize)) {
+      removeSession(fingerprint);
+      return null;
+    }
+    const uploadedBytes = parts.reduce(
+      (sum, part) => sum + (part.size ?? 0),
+      0
+    );
+    updateSessionToken(fingerprint, response.token);
+    updateSessionProgress(fingerprint, uploadedBytes);
+    return {
+      token: response.token,
+      partSize: session.partSize,
+      // Drop `size`: the complete call ignores it, and the wire payload
+      // stays byte-identical to a non-resumed upload's.
+      parts: parts.map(({ partNumber, eTag }) => ({ partNumber, eTag })),
+      uploadedBytes
+    };
+  }
+  /**
+   * Failure teardown. THE behavior change of cross-reload resume: with
+   * `persist` on, an error or abort deliberately leaves the server-side
+   * upload alive so the next attempt can resume into it — pause(), a dropped
+   * connection, and UploadManager's own retries all re-enter `upload()` and
+   * pick the session back up. Without persist this is exactly the historical
+   * best-effort abort. Either way, a 4xx from init/complete kills the
+   * session: the server has already torn the upload down.
+   */
+  async handleUploadFailure(error, token, fingerprint) {
+    if (fingerprint && isUnresumableFailure(error)) {
+      removeSession(fingerprint);
+    }
+    if (this.persist && this.resumeMultipartUpload) return;
+    await this.credentials.abortMultipartUpload?.({ token }).catch(() => {
+    });
+  }
+  /**
+   * PUT one signed part over XMLHttpRequest, under an INACTIVITY watchdog.
+   *
+   * The watchdog resets on every `upload` progress event and fires only after
+   * `partTimeoutMs` with no forward motion at all. That distinction is the
+   * point: `fetch()` for a PUT resolves only once the whole body is sent, so a
+   * flat ceiling on total time aborts a large part on a slow-but-healthy link
+   * (a 5 MiB part under ~233 kbit/s crosses the 180s default) even though it
+   * is uploading fine. An inactivity timer kills the connection the watchdog
+   * was built for — one that has genuinely stopped moving bytes — without
+   * penalizing the slow one. Mirrors the XHR PUT in direct-upload.ts.
+   *
+   * Resolves with the part's ETag. Rejects with: the retryable stall on
+   * inactivity (`partStallError`) — covering both the slice READ and the PUT;
+   * a retryable `UPLOAD_FAILED` when the slice read itself rejects;
+   * `UpupNetworkError('Upload aborted')` when
+   * the caller's signal aborts; a retryable `TypeError` on a network-level
+   * failure (the shape `fetch` produced, which `isRetryablePartFailure`
+   * already classifies); or an `uploadErrorFromResponse` on a non-2xx — its
+   * body read synchronously from `xhr.responseText`, so the whole request
+   * including the error body stays inside the one abort/inactivity window (the
+   * old `await response.text()` ran AFTER the watchdog was cleared and could
+   * hang a half-dead connection forever on the body read).
+   */
+  async putPart(signed, chunk, partNumber, signal) {
+    if (isAborted(signal)) {
+      throw new UpupNetworkError("Upload aborted");
+    }
+    let body = chunk;
+    if (chunk.size <= MATERIALIZE_PART_MAX_BYTES) {
+      let readTimer;
+      let onReadAbort;
+      body = await Promise.race([
+        chunk.arrayBuffer().catch((cause) => {
+          const readErr = new UpupError(
+            `Part ${partNumber} source read failed: ${cause instanceof Error ? cause.message : String(cause)}`,
+            "UPLOAD_FAILED" /* UPLOAD_FAILED */,
+            true
+          );
+          throw readErr;
+        }),
+        new Promise((_, reject) => {
+          readTimer = setTimeout(() => {
+            reject(partStallError(partNumber, this.partTimeoutMs));
+          }, this.partTimeoutMs);
+        }),
+        new Promise((_, reject) => {
+          onReadAbort = () => {
+            const abortErr = new UpupNetworkError("Upload aborted");
+            reject(abortErr);
+          };
+          signal.addEventListener("abort", onReadAbort, {
+            once: true
+          });
+        })
+      ]).finally(() => {
+        clearTimeout(readTimer);
+        if (onReadAbort) {
+          signal.removeEventListener("abort", onReadAbort);
+        }
+      });
+    }
+    if (isAborted(signal)) {
+      throw new UpupNetworkError("Upload aborted");
+    }
+    return new Promise((resolve, reject) => {
+      const xhr = new XMLHttpRequest();
+      let stalled = false;
+      let watchdog;
+      const armWatchdog = () => {
+        clearTimeout(watchdog);
+        watchdog = setTimeout(() => {
+          stalled = true;
+          xhr.abort();
+        }, this.partTimeoutMs);
+      };
+      const forwardAbort = () => {
+        xhr.abort();
+      };
+      const cleanup = () => {
+        clearTimeout(watchdog);
+        signal.removeEventListener("abort", forwardAbort);
+      };
+      xhr.upload.addEventListener("progress", () => {
+        armWatchdog();
+      });
+      xhr.addEventListener("load", () => {
+        cleanup();
+        if (xhr.status >= 200 && xhr.status < 300) {
+          const eTag = xhr.getResponseHeader("ETag") ?? `"part-${partNumber}"`;
+          resolve(eTag);
+          return;
+        }
+        const err = uploadErrorFromResponse({
+          status: xhr.status,
+          statusText: xhr.statusText,
+          body: xhr.responseText,
+          kind: "storage",
+          operation: "multipart-sign-part"
+        });
+        reject(err);
+      });
+      xhr.addEventListener("error", () => {
+        cleanup();
+        const err = new TypeError("Network error during part upload");
+        reject(err);
+      });
+      xhr.addEventListener("abort", () => {
+        cleanup();
+        if (stalled && !isAborted(signal)) {
+          const stallErr = partStallError(
+            partNumber,
+            this.partTimeoutMs
+          );
+          reject(stallErr);
+          return;
+        }
+        const abortErr = new UpupNetworkError("Upload aborted");
+        reject(abortErr);
+      });
+      signal.addEventListener("abort", forwardAbort, { once: true });
+      xhr.open("PUT", signed.uploadUrl);
+      for (const [key, value] of Object.entries(
+        signed.uploadHeaders ?? {}
+      )) {
+        xhr.setRequestHeader(key, value);
+      }
+      armWatchdog();
+      xhr.send(body);
+    });
+  }
+  async upload(file, _credentials, options) {
+    const fileSize = file.size;
+    const fileName = file instanceof File ? file.name : "blob";
+    const fileType = file.type || "application/octet-stream";
+    const fingerprint = this.persist && file instanceof File ? fileFingerprint(file) : null;
+    const contentHash = readContentHash(file);
+    const resumed = fingerprint ? await this.tryResume(fingerprint, fileSize, contentHash) : null;
+    let currentToken;
+    let partSize;
+    const completedParts = [];
+    let totalUploaded = 0;
+    if (resumed) {
+      currentToken = resumed.token;
+      partSize = resumed.partSize;
+      completedParts.push(...resumed.parts);
+      totalUploaded = resumed.uploadedBytes;
+      options.onProgress(totalUploaded, fileSize);
+    } else {
+      let init;
+      try {
+        init = await this.initMultipartUpload({
+          name: fileName,
+          size: fileSize,
+          type: fileType
+        });
+      } catch (error) {
+        if (fingerprint && isClientError(error)) {
+          removeSession(fingerprint);
+        }
+        throw error;
+      }
+      if (!init.token) {
+        throw new UpupNetworkError(
+          "Multipart init did not return an upload token (server too old or misconfigured)"
+        );
+      }
+      currentToken = init.token;
+      partSize = init.partSize || Math.max(this.chunkSizeBytes, Math.ceil(fileSize / MAX_PARTS));
+      if (fingerprint) {
+        saveSession(fingerprint, {
+          token: currentToken,
+          key: init.key,
+          partSize,
+          updatedAt: Date.now(),
+          uploadedBytes: 0,
+          ...this.sessionScope !== void 0 ? { scope: this.sessionScope } : {},
+          ...contentHash !== void 0 ? { contentHash } : {}
+        });
+      }
+    }
+    const totalParts = Math.ceil(fileSize / partSize);
+    let refreshInFlight = null;
+    const refreshToken = async (staleToken) => {
+      const resume = this.resumeMultipartUpload;
+      if (!resume) return null;
+      if (currentToken !== staleToken) return currentToken;
+      const pending = refreshInFlight ?? resume({ token: staleToken }).then((response) => {
+        currentToken = response.token;
+        if (fingerprint) {
+          updateSessionToken(fingerprint, response.token);
+        }
+        return response.token;
+      }).catch(() => null).finally(() => {
+        refreshInFlight = null;
+      });
+      refreshInFlight = pending;
+      return pending;
+    };
+    const withTokenRefresh = async (call) => {
+      const attemptToken = currentToken;
+      try {
+        return await call(attemptToken);
+      } catch (error) {
+        if (!isExpiredTokenError(error)) throw error;
+        const freshToken = await refreshToken(attemptToken);
+        if (!freshToken) throw error;
+        return call(freshToken);
+      }
+    };
+    try {
+      const alreadyUploaded = new Set(
+        completedParts.map((part) => part.partNumber)
+      );
+      const partQueue = Array.from(
+        { length: totalParts },
+        (_, i) => i + 1
+      ).filter((partNumber) => !alreadyUploaded.has(partNumber));
+      const activeParts = [];
+      const attemptPart = async (partNumber) => {
+        const start = (partNumber - 1) * partSize;
+        const end = Math.min(start + partSize, fileSize);
+        const chunk = file.slice(start, end);
+        let signTimer;
+        const signed = await Promise.race([
+          withTokenRefresh(
+            (token) => this.signPart({
+              token,
+              partNumber
+            })
+          ),
+          new Promise((_, reject) => {
+            signTimer = setTimeout(() => {
+              reject(
+                partStallError(partNumber, this.partTimeoutMs)
+              );
+            }, this.partTimeoutMs);
+          })
+        ]).finally(() => {
+          clearTimeout(signTimer);
+        });
+        if (isAborted(options.signal)) {
+          throw new UpupNetworkError("Upload aborted");
+        }
+        const eTag = await this.putPart(
+          signed,
+          chunk,
+          partNumber,
+          options.signal
+        );
+        completedParts.push({ partNumber, eTag });
+        totalUploaded += end - start;
+        options.onProgress(totalUploaded, fileSize);
+        if (fingerprint) {
+          updateSessionProgress(fingerprint, totalUploaded);
+        }
+      };
+      const uploadPart = async (partNumber) => {
+        for (let attempt = 0; ; attempt++) {
+          if (isAborted(options.signal)) {
+            throw new UpupNetworkError("Upload aborted");
+          }
+          try {
+            await attemptPart(partNumber);
+            return;
+          } catch (error) {
+            if (isAborted(options.signal)) throw error;
+            const delay = this.retryDelays[attempt];
+            if (delay === void 0 || !isRetryablePartFailure(error)) {
+              throw error;
+            }
+            await abortableDelay(delay, options.signal);
+          }
+        }
+      };
+      for (const partNumber of partQueue) {
+        if (options.signal.aborted) break;
+        const partPromise = uploadPart(partNumber).then(() => {
+          const idx = activeParts.indexOf(partPromise);
+          if (idx !== -1) void activeParts.splice(idx, 1);
+        });
+        activeParts.push(partPromise);
+        if (activeParts.length >= this.maxConcurrentParts) {
+          await Promise.race(activeParts);
+        }
+      }
+      await Promise.all(activeParts);
+      if (isAborted(options.signal)) {
+        throw new UpupNetworkError("Upload aborted");
+      }
+      completedParts.sort((a, b) => a.partNumber - b.partNumber);
+      const result = await withTokenRefresh(
+        (token) => this.completeMultipartUpload({
+          token,
+          parts: completedParts
+        })
+      );
+      if (fingerprint) removeSession(fingerprint);
+      return {
+        key: result.key,
+        publicUrl: result.publicUrl,
+        downloadUrl: result.downloadUrl,
+        etag: result.etag
+      };
+    } catch (error) {
+      await this.handleUploadFailure(error, currentToken, fingerprint);
+      throw error;
+    }
+  }
+};
+
+export { MultipartUpload, ServerCredentials, abortPersistedMultipartSessions };

package/dist/chunk-N2SLHVAW.cjs

@@ -0,0 +1,61 @@
+'use strict';
+
+// src/types/file-source.ts
+var FileSource = /* @__PURE__ */ ((FileSource2) => {
+  FileSource2["LOCAL"] = "local";
+  FileSource2["GOOGLE_DRIVE"] = "googleDrive";
+  FileSource2["ONE_DRIVE"] = "oneDrive";
+  FileSource2["DROPBOX"] = "dropbox";
+  FileSource2["BOX"] = "box";
+  FileSource2["URL"] = "url";
+  FileSource2["CAMERA"] = "camera";
+  FileSource2["MICROPHONE"] = "microphone";
+  FileSource2["SCREEN"] = "screen";
+  return FileSource2;
+})(FileSource || {});
+
+// src/types/storage-provider.ts
+var StorageProvider = /* @__PURE__ */ ((StorageProvider2) => {
+  StorageProvider2["AWS"] = "aws";
+  StorageProvider2["Azure"] = "azure";
+  StorageProvider2["BackBlaze"] = "backblaze";
+  StorageProvider2["DigitalOcean"] = "digitalocean";
+  StorageProvider2["CloudflareR2"] = "r2";
+  StorageProvider2["Wasabi"] = "wasabi";
+  StorageProvider2["MinIO"] = "minio";
+  StorageProvider2["GCS"] = "gcs";
+  StorageProvider2["Supabase"] = "supabase";
+  StorageProvider2["Hetzner"] = "hetzner";
+  StorageProvider2["Linode"] = "linode";
+  StorageProvider2["Vultr"] = "vultr";
+  StorageProvider2["UpCloud"] = "upcloud";
+  StorageProvider2["Scaleway"] = "scaleway";
+  StorageProvider2["OVHcloud"] = "ovhcloud";
+  StorageProvider2["Alibaba"] = "alibaba";
+  StorageProvider2["Oracle"] = "oracle";
+  StorageProvider2["Contabo"] = "contabo";
+  StorageProvider2["Storj"] = "storj";
+  StorageProvider2["IDrive"] = "idrive";
+  StorageProvider2["Ceph"] = "ceph";
+  return StorageProvider2;
+})(StorageProvider || {});
+var NON_S3_STORAGE_PROVIDERS = /* @__PURE__ */ new Set([
+  "azure" /* Azure */
+]);
+
+// src/types/upload-status.ts
+var UploadStatus = /* @__PURE__ */ ((UploadStatus2) => {
+  UploadStatus2["IDLE"] = "IDLE";
+  UploadStatus2["PROCESSING"] = "PROCESSING";
+  UploadStatus2["READY"] = "READY";
+  UploadStatus2["UPLOADING"] = "UPLOADING";
+  UploadStatus2["PAUSED"] = "PAUSED";
+  UploadStatus2["SUCCESSFUL"] = "SUCCESSFUL";
+  UploadStatus2["FAILED"] = "FAILED";
+  return UploadStatus2;
+})(UploadStatus || {});
+
+exports.FileSource = FileSource;
+exports.NON_S3_STORAGE_PROVIDERS = NON_S3_STORAGE_PROVIDERS;
+exports.StorageProvider = StorageProvider;
+exports.UploadStatus = UploadStatus;