@zero-transfer/sdk 0.1.1 → 0.1.2

package/dist/index.cjs

@@ -2601,6 +2601,74 @@ var FtpFileSystem = class {
       path: remotePath
     };
   }
+  async remove(path2, options = {}) {
+    const remotePath = normalizeFtpPath(path2);
+    const response = await this.control.sendCommand(`DELE ${remotePath}`);
+    if (response.completion) return;
+    if (response.code === 550 && options.ignoreMissing) return;
+    assertPathCommandSucceeded(response, "DELE", remotePath, this.control.providerId);
+  }
+  async rename(from, to) {
+    const fromPath = normalizeFtpPath(from);
+    const toPath = normalizeFtpPath(to);
+    const rnfr = await this.control.sendCommand(`RNFR ${fromPath}`);
+    if (!rnfr.intermediate && !rnfr.completion) {
+      assertPathCommandSucceeded(rnfr, "RNFR", fromPath, this.control.providerId);
+    }
+    await expectCompletion(this.control, `RNTO ${toPath}`, toPath);
+  }
+  async mkdir(path2, options = {}) {
+    const remotePath = normalizeFtpPath(path2);
+    if (!options.recursive) {
+      await expectCompletion(this.control, `MKD ${remotePath}`, remotePath);
+      return;
+    }
+    const segments = remotePath.split("/").filter((s) => s.length > 0);
+    let current = "";
+    for (const segment of segments) {
+      current = `${current}/${segment}`;
+      const response = await this.control.sendCommand(`MKD ${current}`);
+      if (response.completion) continue;
+      if (response.code === 550) continue;
+      assertPathCommandSucceeded(response, "MKD", current, this.control.providerId);
+    }
+  }
+  async rmdir(path2, options = {}) {
+    const remotePath = normalizeFtpPath(path2);
+    if (options.recursive) {
+      await this.removeDirectoryRecursive(remotePath);
+      return;
+    }
+    const response = await this.control.sendCommand(`RMD ${remotePath}`);
+    if (response.completion) return;
+    if (response.code === 550 && options.ignoreMissing) return;
+    assertPathCommandSucceeded(response, "RMD", remotePath, this.control.providerId);
+  }
+  async removeDirectoryRecursive(remotePath) {
+    let entries;
+    try {
+      entries = await readDirectoryEntries(this.control, remotePath);
+    } catch (error) {
+      if (error instanceof PathNotFoundError) return;
+      throw error;
+    }
+    for (const entry of entries) {
+      if (entry.name === "." || entry.name === "..") continue;
+      const childPath = entry.path.startsWith("/") ? entry.path : normalizeFtpPath(`${remotePath.replace(/\/+$/, "")}/${entry.name}`);
+      if (entry.type === "directory") {
+        await this.removeDirectoryRecursive(childPath);
+      } else {
+        const del = await this.control.sendCommand(`DELE ${childPath}`);
+        if (!del.completion && del.code !== 550) {
+          assertPathCommandSucceeded(del, "DELE", childPath, this.control.providerId);
+        }
+      }
+    }
+    const response = await this.control.sendCommand(`RMD ${remotePath}`);
+    if (response.completion) return;
+    if (response.code === 550) return;
+    assertPathCommandSucceeded(response, "RMD", remotePath, this.control.providerId);
+  }
 };
 var FtpControlConnection = class _FtpControlConnection {
   /**
@@ -3793,6 +3861,101 @@ var SftpFileSystem = class {
       throw mapSftpError(error, { command: "LSTAT", path: remotePath });
     }
   }
+  async remove(path2, options = {}) {
+    throwIfAborted2(options.signal, path2, "remove");
+    const remotePath = normalizeSftpPath(path2);
+    try {
+      await sftpUnlink(this.sftp, remotePath);
+    } catch (error) {
+      const mapped = mapSftpError(error, { command: "REMOVE", path: remotePath });
+      if (options.ignoreMissing && mapped instanceof PathNotFoundError) return;
+      throw mapped;
+    }
+  }
+  async rename(from, to, options = {}) {
+    throwIfAborted2(options.signal, from, "rename");
+    const fromPath = normalizeSftpPath(from);
+    const toPath = normalizeSftpPath(to);
+    try {
+      await sftpRename(this.sftp, fromPath, toPath);
+    } catch (error) {
+      throw mapSftpError(error, { command: "RENAME", path: fromPath });
+    }
+  }
+  async mkdir(path2, options = {}) {
+    throwIfAborted2(options.signal, path2, "mkdir");
+    const remotePath = normalizeSftpPath(path2);
+    if (!options.recursive) {
+      try {
+        await sftpMkdir(this.sftp, remotePath);
+      } catch (error) {
+        throw mapSftpError(error, { command: "MKDIR", path: remotePath });
+      }
+      return;
+    }
+    const segments = remotePath.split("/").filter((s) => s.length > 0);
+    let current = "";
+    for (const segment of segments) {
+      current = `${current}/${segment}`;
+      try {
+        await sftpMkdir(this.sftp, current);
+      } catch (error) {
+        try {
+          const stats = await readSftpStats(this.sftp, current);
+          if (stats.isDirectory()) continue;
+        } catch {
+        }
+        throw mapSftpError(error, { command: "MKDIR", path: current });
+      }
+    }
+  }
+  async rmdir(path2, options = {}) {
+    throwIfAborted2(options.signal, path2, "rmdir");
+    const remotePath = normalizeSftpPath(path2);
+    if (options.recursive) {
+      await this.removeDirectoryRecursive(remotePath);
+      return;
+    }
+    try {
+      await sftpRmdir(this.sftp, remotePath);
+    } catch (error) {
+      const mapped = mapSftpError(error, { command: "RMDIR", path: remotePath });
+      if (options.ignoreMissing && mapped instanceof PathNotFoundError) return;
+      throw mapped;
+    }
+  }
+  async removeDirectoryRecursive(remotePath) {
+    let entries;
+    try {
+      entries = await readSftpDirectory(this.sftp, remotePath);
+    } catch (error) {
+      const mapped = mapSftpError(error, { command: "READDIR", path: remotePath });
+      if (mapped instanceof PathNotFoundError) return;
+      throw mapped;
+    }
+    for (const entry of entries) {
+      if (entry.filename === "." || entry.filename === "..") continue;
+      const childPath = `${remotePath.replace(/\/+$/, "")}/${entry.filename}`.replace(/\/+/g, "/");
+      const isDir = entry.attrs.isDirectory();
+      try {
+        if (isDir) {
+          await this.removeDirectoryRecursive(childPath);
+        } else {
+          await sftpUnlink(this.sftp, childPath);
+        }
+      } catch (error) {
+        throw mapSftpError(error, {
+          command: isDir ? "RMDIR" : "REMOVE",
+          path: childPath
+        });
+      }
+    }
+    try {
+      await sftpRmdir(this.sftp, remotePath);
+    } catch (error) {
+      throw mapSftpError(error, { command: "RMDIR", path: remotePath });
+    }
+  }
 };
 async function connectSshClient(profile, options, username, authentication) {
   const client = new SshClientCtor();
@@ -4184,6 +4347,50 @@ function readSftpStats(sftp, path2) {
     });
   });
 }
+function sftpUnlink(sftp, path2) {
+  return new Promise((resolve, reject) => {
+    sftp.unlink(path2, (error) => {
+      if (error !== void 0 && error !== null) {
+        reject(error);
+        return;
+      }
+      resolve();
+    });
+  });
+}
+function sftpRename(sftp, from, to) {
+  return new Promise((resolve, reject) => {
+    sftp.rename(from, to, (error) => {
+      if (error !== void 0 && error !== null) {
+        reject(error);
+        return;
+      }
+      resolve();
+    });
+  });
+}
+function sftpMkdir(sftp, path2) {
+  return new Promise((resolve, reject) => {
+    sftp.mkdir(path2, (error) => {
+      if (error !== void 0 && error !== null) {
+        reject(error);
+        return;
+      }
+      resolve();
+    });
+  });
+}
+function sftpRmdir(sftp, path2) {
+  return new Promise((resolve, reject) => {
+    sftp.rmdir(path2, (error) => {
+      if (error !== void 0 && error !== null) {
+        reject(error);
+        return;
+      }
+      resolve();
+    });
+  });
+}
 async function* createSftpReadSource(sftp, path2, range, request) {
   if (range.length <= 0) {
     return;
@@ -7019,7 +7226,55 @@ var LocalFileSystem = class {
   async stat(path2) {
     return readLocalEntry(this.rootPath, normalizeLocalProviderPath(path2));
   }
+  async remove(remote, options = {}) {
+    const remotePath = normalizeLocalProviderPath(remote);
+    const localPath = resolveLocalPath(this.rootPath, remotePath);
+    try {
+      await (0, import_promises2.unlink)(localPath);
+    } catch (error) {
+      if (options.ignoreMissing && isNodeErrno(error, "ENOENT")) return;
+      if (isNodeErrno(error, "ENOENT")) {
+        throw createPathNotFoundError(remotePath, `Local path not found: ${remotePath}`);
+      }
+      throw error;
+    }
+  }
+  async rename(from, to) {
+    const fromRemote = normalizeLocalProviderPath(from);
+    const toRemote = normalizeLocalProviderPath(to);
+    const fromLocal = resolveLocalPath(this.rootPath, fromRemote);
+    const toLocal = resolveLocalPath(this.rootPath, toRemote);
+    try {
+      await (0, import_promises2.rename)(fromLocal, toLocal);
+    } catch (error) {
+      if (isNodeErrno(error, "ENOENT")) {
+        throw createPathNotFoundError(fromRemote, `Local path not found: ${fromRemote}`);
+      }
+      throw error;
+    }
+  }
+  async mkdir(remote, options = {}) {
+    const remotePath = normalizeLocalProviderPath(remote);
+    const localPath = resolveLocalPath(this.rootPath, remotePath);
+    await (0, import_promises2.mkdir)(localPath, { recursive: options.recursive === true });
+  }
+  async rmdir(remote, options = {}) {
+    const remotePath = normalizeLocalProviderPath(remote);
+    const localPath = resolveLocalPath(this.rootPath, remotePath);
+    try {
+      await (0, import_promises2.rm)(localPath, { recursive: options.recursive === true, force: false });
+    } catch (error) {
+      if (isNodeErrno(error, "ENOENT")) {
+        if (options.ignoreMissing) return;
+        throw createPathNotFoundError(remotePath, `Local path not found: ${remotePath}`);
+      }
+      throw error;
+    }
+  }
 };
+function isNodeErrno(error, code) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === code;
+}
 function resolveReadRange2(size, range) {
   if (range === void 0) {
     return { length: size, offset: 0 };
@@ -7338,6 +7593,96 @@ var MemoryFileSystem = class {
       () => cloneRemoteStat(this.requireEntry(normalizeMemoryPath(path2)))
     );
   }
+  remove(path2, options = {}) {
+    return Promise.resolve().then(() => {
+      const normalized = normalizeMemoryPath(path2);
+      const entry = this.state.entries.get(normalized);
+      if (entry === void 0) {
+        if (options.ignoreMissing) return;
+        throw createPathNotFoundError2(normalized, `Memory path not found: ${normalized}`);
+      }
+      if (entry.type === "directory") {
+        throw createPathNotFoundError2(
+          normalized,
+          `Memory path is a directory; use rmdir: ${normalized}`
+        );
+      }
+      this.state.entries.delete(normalized);
+      this.state.content.delete(normalized);
+    });
+  }
+  rename(from, to) {
+    return Promise.resolve().then(() => {
+      const fromPath = normalizeMemoryPath(from);
+      const toPath = normalizeMemoryPath(to);
+      const entry = this.state.entries.get(fromPath);
+      if (entry === void 0) {
+        throw createPathNotFoundError2(fromPath, `Memory path not found: ${fromPath}`);
+      }
+      ensureParentDirectories(this.state.entries, toPath);
+      const moved = { ...entry, path: toPath, name: basenameRemotePath(toPath) };
+      this.state.entries.delete(fromPath);
+      this.state.entries.set(toPath, moved);
+      const content = this.state.content.get(fromPath);
+      if (content !== void 0) {
+        this.state.content.delete(fromPath);
+        this.state.content.set(toPath, content);
+      }
+    });
+  }
+  mkdir(path2, options = {}) {
+    return Promise.resolve().then(() => {
+      const normalized = normalizeMemoryPath(path2);
+      const existing = this.state.entries.get(normalized);
+      if (existing !== void 0) {
+        if (existing.type === "directory" && options.recursive) return;
+        throw createInvalidFixtureError(normalized, `Memory path already exists: ${normalized}`);
+      }
+      if (options.recursive) {
+        ensureParentDirectories(this.state.entries, normalized);
+      } else {
+        const parent = getParentPath2(normalized);
+        if (parent !== void 0 && !this.state.entries.has(parent)) {
+          throw createPathNotFoundError2(parent, `Memory parent not found: ${parent}`);
+        }
+      }
+      this.state.entries.set(normalized, createDirectoryEntry(normalized));
+    });
+  }
+  rmdir(path2, options = {}) {
+    return Promise.resolve().then(() => {
+      const normalized = normalizeMemoryPath(path2);
+      const entry = this.state.entries.get(normalized);
+      if (entry === void 0) {
+        if (options.ignoreMissing) return;
+        throw createPathNotFoundError2(normalized, `Memory path not found: ${normalized}`);
+      }
+      if (entry.type !== "directory") {
+        throw createPathNotFoundError2(normalized, `Memory path is not a directory: ${normalized}`);
+      }
+      const children = [...this.state.entries.values()].filter(
+        (child) => child.path !== normalized && getParentPath2(child.path) === normalized
+      );
+      if (children.length > 0 && !options.recursive) {
+        throw createInvalidFixtureError(normalized, `Memory directory not empty: ${normalized}`);
+      }
+      const stack = [...children];
+      while (stack.length > 0) {
+        const next = stack.pop();
+        if (!next) continue;
+        if (next.type === "directory") {
+          for (const grand of this.state.entries.values()) {
+            if (grand.path !== next.path && getParentPath2(grand.path) === next.path) {
+              stack.push(grand);
+            }
+          }
+        }
+        this.state.entries.delete(next.path);
+        this.state.content.delete(next.path);
+      }
+      this.state.entries.delete(normalized);
+    });
+  }
   requireEntry(path2) {
     const entry = this.state.entries.get(path2);
     if (entry === void 0) {