@zero-transfer/webdav 0.3.1 → 0.4.2

package/dist/index.cjs

@@ -63,6 +63,7 @@ __export(webdav_exports, {
   createLocalProviderFactory: () => createLocalProviderFactory,
   createMemoryProviderFactory: () => createMemoryProviderFactory,
   createOAuthTokenSecretSource: () => createOAuthTokenSecretSource,
+  createPooledTransferClient: () => createPooledTransferClient,
   createProgressEvent: () => createProgressEvent,
   createProviderTransferExecutor: () => createProviderTransferExecutor,
   createRemoteBrowser: () => createRemoteBrowser,
@@ -1882,6 +1883,186 @@ function summarizeDiagnosticError(error) {
   return { message: String(error) };
 }
 
+// src/core/ConnectionPool.ts
+var DEFAULT_MAX_IDLE_PER_KEY = 4;
+var DEFAULT_IDLE_TIMEOUT_MS = 6e4;
+function createPooledTransferClient(inner, options = {}) {
+  const maxIdlePerKey = Math.max(1, options.maxIdlePerKey ?? DEFAULT_MAX_IDLE_PER_KEY);
+  const idleTimeoutMs = Math.max(0, options.idleTimeoutMs ?? DEFAULT_IDLE_TIMEOUT_MS);
+  const keyOf = options.keyOf ?? defaultKeyOf;
+  const state = {
+    drained: false,
+    idle: /* @__PURE__ */ new Map()
+  };
+  const release = (key, session, tainted) => {
+    if (tainted || state.drained) {
+      return safelyDisconnect(session);
+    }
+    let bucket = state.idle.get(key);
+    if (bucket === void 0) {
+      bucket = [];
+      state.idle.set(key, bucket);
+    }
+    const entry = { session };
+    if (idleTimeoutMs > 0) {
+      entry.idleTimer = setTimeout(() => {
+        evictEntry(state, key, entry);
+      }, idleTimeoutMs);
+      const timer = entry.idleTimer;
+      if (timer !== void 0 && typeof timer.unref === "function") {
+        timer.unref();
+      }
+    }
+    bucket.push(entry);
+    while (bucket.length > maxIdlePerKey) {
+      const dropped = bucket.shift();
+      if (dropped !== void 0) {
+        clearEntryTimer(dropped);
+        void safelyDisconnect(dropped.session);
+      }
+    }
+    return Promise.resolve();
+  };
+  const acquire = async (profile) => {
+    const key = keyOf(profile);
+    const bucket = state.idle.get(key);
+    if (bucket !== void 0 && bucket.length > 0) {
+      const entry = bucket.pop();
+      if (entry !== void 0) {
+        clearEntryTimer(entry);
+        if (bucket.length === 0) state.idle.delete(key);
+        return { key, session: entry.session };
+      }
+    }
+    const session = await inner.connect(profile);
+    return { key, session };
+  };
+  return {
+    connect: async (profile) => {
+      const { key, session } = await acquire(profile);
+      return wrapPooledSession(session, key, release);
+    },
+    drainPool: async () => {
+      state.drained = true;
+      const entries = [];
+      for (const bucket of state.idle.values()) {
+        for (const entry of bucket) {
+          clearEntryTimer(entry);
+          entries.push(entry);
+        }
+      }
+      state.idle.clear();
+      await Promise.all(entries.map((entry) => safelyDisconnect(entry.session)));
+    },
+    getCapabilities: ((providerId) => {
+      if (providerId === void 0) return inner.getCapabilities();
+      return inner.getCapabilities(providerId);
+    }),
+    hasProvider: (providerId) => inner.hasProvider(providerId),
+    poolSize: () => {
+      let total = 0;
+      for (const bucket of state.idle.values()) total += bucket.length;
+      return total;
+    }
+  };
+}
+function defaultKeyOf(profile) {
+  const provider = profile.provider ?? profile.protocol ?? "unknown";
+  const host = profile.host ?? "";
+  const port = profile.port ?? "";
+  const username = typeof profile.username === "string" ? profile.username : "";
+  return `${provider}|${host}|${String(port)}|${username}`;
+}
+function evictEntry(state, key, entry) {
+  const bucket = state.idle.get(key);
+  if (bucket === void 0) return;
+  const index = bucket.indexOf(entry);
+  if (index < 0) return;
+  bucket.splice(index, 1);
+  if (bucket.length === 0) state.idle.delete(key);
+  clearEntryTimer(entry);
+  void safelyDisconnect(entry.session);
+}
+function clearEntryTimer(entry) {
+  if (entry.idleTimer !== void 0) {
+    clearTimeout(entry.idleTimer);
+    delete entry.idleTimer;
+  }
+}
+async function safelyDisconnect(session) {
+  try {
+    await session.disconnect();
+  } catch {
+  }
+}
+function isTaintingError(error) {
+  return error instanceof ConnectionError || error instanceof TimeoutError || error instanceof ProtocolError;
+}
+function wrapPooledSession(session, key, release) {
+  let tainted = false;
+  let released = false;
+  const guard = (fn) => {
+    let promise;
+    try {
+      promise = fn();
+    } catch (error) {
+      if (isTaintingError(error)) tainted = true;
+      return Promise.reject(error instanceof Error ? error : new Error(String(error)));
+    }
+    return promise.catch((error) => {
+      if (isTaintingError(error)) tainted = true;
+      throw error;
+    });
+  };
+  const fs = wrapFs(session.fs, guard);
+  const transfers = session.transfers === void 0 ? void 0 : wrapTransfers(session.transfers, guard);
+  const wrapped = {
+    capabilities: session.capabilities,
+    disconnect: async () => {
+      if (released) return;
+      released = true;
+      await release(key, session, tainted);
+    },
+    fs,
+    provider: session.provider,
+    ...transfers !== void 0 ? { transfers } : {}
+  };
+  if (typeof session.raw === "function") {
+    const rawFn = session.raw.bind(session);
+    wrapped.raw = () => rawFn();
+  }
+  return wrapped;
+}
+function wrapFs(fs, guard) {
+  const wrapped = {
+    list: (path2, options) => guard(() => options !== void 0 ? fs.list(path2, options) : fs.list(path2)),
+    stat: (path2, options) => guard(() => options !== void 0 ? fs.stat(path2, options) : fs.stat(path2))
+  };
+  if (typeof fs.remove === "function") {
+    const remove = fs.remove.bind(fs);
+    wrapped.remove = (path2, options) => guard(() => options !== void 0 ? remove(path2, options) : remove(path2));
+  }
+  if (typeof fs.rename === "function") {
+    const rename2 = fs.rename.bind(fs);
+    wrapped.rename = (from, to, options) => guard(() => options !== void 0 ? rename2(from, to, options) : rename2(from, to));
+  }
+  if (typeof fs.mkdir === "function") {
+    const mkdir2 = fs.mkdir.bind(fs);
+    wrapped.mkdir = (path2, options) => guard(() => options !== void 0 ? mkdir2(path2, options) : mkdir2(path2));
+  }
+  if (typeof fs.rmdir === "function") {
+    const rmdir = fs.rmdir.bind(fs);
+    wrapped.rmdir = (path2, options) => guard(() => options !== void 0 ? rmdir(path2, options) : rmdir(path2));
+  }
+  return wrapped;
+}
+function wrapTransfers(transfers, guard) {
+  return {
+    read: (request) => guard(() => Promise.resolve(transfers.read(request))),
+    write: (request) => guard(() => Promise.resolve(transfers.write(request)))
+  };
+}
+
 // src/providers/local/LocalProvider.ts
 var import_node_fs = require("fs");
 var import_promises2 = require("fs/promises");
@@ -4861,12 +5042,14 @@ function createWebDavProviderFactory(options = {}) {
   const secure = options.secure ?? false;
   const basePath = options.basePath ?? "";
   const fetchImpl = options.fetch ?? globalThis.fetch;
+  const uploadStreaming = options.uploadStreaming ?? "when-known-size";
   if (typeof fetchImpl !== "function") {
     throw new ConfigurationError({
       message: "Global fetch is unavailable; supply WebDavProviderOptions.fetch explicitly",
       retryable: false
     });
   }
+  const streamingNote = uploadStreaming === "always" ? "PUT bodies are always streamed (chunked when size is unknown)." : uploadStreaming === "never" ? "PUT bodies are buffered in memory (uploadStreaming: 'never')." : "PUT bodies stream when totalBytes is known; otherwise buffered in memory.";
   const capabilities = {
     atomicRename: false,
     authentication: ["anonymous", "password", "token"],
@@ -4876,7 +5059,7 @@ function createWebDavProviderFactory(options = {}) {
     list: true,
     maxConcurrency: 8,
     metadata: ["modifiedAt", "mimeType", "uniqueId"],
-    notes: ["WebDAV provider buffers PUT bodies in memory; chunked uploads are not yet supported."],
+    notes: [streamingNote],
     provider: id,
     readStream: true,
     resumeDownload: true,
@@ -4895,7 +5078,8 @@ function createWebDavProviderFactory(options = {}) {
       defaultHeaders: { ...options.defaultHeaders ?? {} },
       fetch: fetchImpl,
       id,
-      secure
+      secure,
+      uploadStreaming
     }),
     id
   };
@@ -4929,7 +5113,8 @@ var WebDavProvider = class {
       capabilities: this.internals.capabilities,
       fetch: this.internals.fetch,
       headers,
-      id: this.internals.id
+      id: this.internals.id,
+      uploadStreaming: this.internals.uploadStreaming
     };
     if (profile.timeoutMs !== void 0) sessionOptions.timeoutMs = profile.timeoutMs;
     return new WebDavSession(sessionOptions);
@@ -5054,13 +5239,53 @@ var WebDavTransferOperations = class {
     }
     const normalized = normalizeRemotePath(request.endpoint.path);
     const url = resolveUrl(this.options.baseUrl, normalized);
-    const buffered = await collectChunks(request.content);
+    const totalBytes = request.totalBytes;
+    const policy = this.options.uploadStreaming;
+    const shouldStream = policy === "always" || policy === "when-known-size" && typeof totalBytes === "number" && totalBytes >= 0;
+    if (!shouldStream) {
+      const buffered = await collectChunks(request.content);
+      const headers2 = {
+        "Content-Length": String(buffered.byteLength),
+        "Content-Type": "application/octet-stream"
+      };
+      const init2 = {
+        body: buffered,
+        headers: headers2,
+        method: "PUT"
+      };
+      if (request.signal !== void 0) init2.signal = request.signal;
+      const response2 = await dispatchRequest(this.options, url, init2);
+      if (!response2.ok) {
+        throw mapResponseError(response2, normalized);
+      }
+      request.reportProgress(buffered.byteLength, buffered.byteLength);
+      const result2 = {
+        bytesTransferred: buffered.byteLength,
+        totalBytes: buffered.byteLength
+      };
+      const etag2 = response2.headers.get("etag");
+      if (etag2 !== null) result2.checksum = etag2;
+      return result2;
+    }
+    let bytesTransferred = 0;
+    const knownTotal = typeof totalBytes === "number" ? totalBytes : void 0;
+    const stream = asyncIterableToReadableStream(request.content, (chunk) => {
+      bytesTransferred += chunk.byteLength;
+      if (knownTotal !== void 0) {
+        request.reportProgress(bytesTransferred, knownTotal);
+      } else {
+        request.reportProgress(bytesTransferred);
+      }
+    });
     const headers = {
-      "Content-Length": String(buffered.byteLength),
       "Content-Type": "application/octet-stream"
     };
+    if (knownTotal !== void 0) {
+      headers["Content-Length"] = String(knownTotal);
+    }
     const init = {
-      body: buffered,
+      body: stream,
+      duplex: "half",
       headers,
       method: "PUT"
     };
@@ -5069,10 +5294,9 @@ var WebDavTransferOperations = class {
     if (!response.ok) {
       throw mapResponseError(response, normalized);
     }
-    request.reportProgress(buffered.byteLength, buffered.byteLength);
     const result = {
-      bytesTransferred: buffered.byteLength,
-      totalBytes: buffered.byteLength
+      bytesTransferred,
+      ...knownTotal !== void 0 ? { totalBytes: knownTotal } : { totalBytes: bytesTransferred }
     };
     const etag = response.headers.get("etag");
     if (etag !== null) result.checksum = etag;
@@ -5094,6 +5318,36 @@ async function collectChunks(source) {
   }
   return out;
 }
+function asyncIterableToReadableStream(source, onChunk) {
+  const iterator = source[Symbol.asyncIterator]();
+  return new ReadableStream({
+    async pull(controller) {
+      try {
+        const next = await iterator.next();
+        if (next.done === true) {
+          controller.close();
+          return;
+        }
+        const chunk = next.value;
+        if (chunk.byteLength === 0) {
+          return;
+        }
+        controller.enqueue(chunk);
+        onChunk(chunk);
+      } catch (error) {
+        controller.error(error);
+      }
+    },
+    async cancel(reason) {
+      if (typeof iterator.return === "function") {
+        try {
+          await iterator.return(reason);
+        } catch {
+        }
+      }
+    }
+  });
+}
 function parsePropfindResponses(xml, baseUrl) {
   const entries = [];
   const responseRegex = /<(?:[a-zA-Z0-9-]+:)?response\b[^>]*>([\s\S]*?)<\/(?:[a-zA-Z0-9-]+:)?response>/gi;
@@ -5207,6 +5461,7 @@ function parentOf(path2) {
   createLocalProviderFactory,
   createMemoryProviderFactory,
   createOAuthTokenSecretSource,
+  createPooledTransferClient,
   createProgressEvent,
   createProviderTransferExecutor,
   createRemoteBrowser,