@design-edito/tools 0.4.3 → 0.4.5

package/node/cloud-storage/operations/move-dir/index.js

@@ -1,26 +1,161 @@
+// src/agnostic/misc/outcome/index.ts
+function makeSuccess(payload) {
+  return { success: true, payload };
+}
+function makeFailure(error) {
+  return { success: false, error };
+}
+
+// src/node/cloud-storage/clients/index.ts
+import { Bucket as GCSBucket } from "@google-cloud/storage";
+import { S3Client } from "@aws-sdk/client-s3";
+import { Client as FtpClient } from "basic-ftp";
+import SftpClient from "ssh2-sftp-client";
+var isGcsBucket = (client) => client instanceof GCSBucket;
+var isS3ClientWithBucket = (client) => "bucketName" in client && typeof client.bucketName === "string" && "client" in client && client.client instanceof S3Client;
+var isFtpClient = (client) => client instanceof FtpClient;
+var isSftpClient = (client) => client instanceof SftpClient;
+
+// src/agnostic/errors/unknown-to-string/index.ts
+function unknownToString(unk, encoding) {
+  if (unk instanceof Error) return unk.message;
+  if (unk instanceof Buffer) return unk.toString(encoding ?? "utf-8");
+  if (typeof unk === "string") return unk;
+  if (typeof unk === "object" && unk !== null) return JSON.stringify(unk);
+  return `${unk}`;
+}
+
+// src/node/ftps/directory/move-dir/index.ts
+async function moveDir(ftpClient, sourceDir, targetDir, options) {
+  const { overwrite = false, ensureDir = true } = options ?? {};
+  try {
+    if (ensureDir) {
+      const parentDir = targetDir.substring(0, targetDir.lastIndexOf("/"));
+      await ftpClient.ensureDir(parentDir);
+    }
+    if (!overwrite) {
+      try {
+        await ftpClient.size(targetDir);
+        return makeFailure(`Target ${targetDir} already exists.`);
+      } catch {
+      }
+    }
+    await ftpClient.rename(sourceDir, targetDir);
+    return makeSuccess(true);
+  } catch (err) {
+    return makeFailure(unknownToString(err));
+  }
+}
+
+// src/node/sftp/directory/move-dir/index.ts
+async function moveDir2(sftp, sourceDir, targetDir, options) {
+  const { overwrite = false, ensureDir = true } = options ?? {};
+  try {
+    if (ensureDir) {
+      const parentDir = targetDir.substring(0, targetDir.lastIndexOf("/"));
+      await sftp.mkdir(parentDir, true);
+    }
+    if (!overwrite) {
+      const exists = await sftp.exists(targetDir);
+      if (exists !== false) return makeFailure(`Target ${targetDir} already exists.`);
+    }
+    await sftp.rename(sourceDir, targetDir);
+    return makeSuccess(true);
+  } catch (err) {
+    return makeFailure(unknownToString(err));
+  }
+}
+
+// src/node/@aws-s3/storage/directory/move-dir/index.ts
 import {
-  moveDir as moveDir4
-} from "../../../../chunks/chunk-OAX7GS7C.js";
-import {
-  moveDir as moveDir3
-} from "../../../../chunks/chunk-B5V7D2ZL.js";
-import {
-  moveDir as moveDir2
-} from "../../../../chunks/chunk-TAXFCVFE.js";
-import {
-  moveDir
-} from "../../../../chunks/chunk-BCX4HPD7.js";
-import {
-  isFtpClient,
-  isGcsBucket,
-  isS3ClientWithBucket,
-  isSftpClient
-} from "../../../../chunks/chunk-ISJONMNA.js";
-import {
-  makeFailure
-} from "../../../../chunks/chunk-LUAYN7VJ.js";
-import "../../../../chunks/chunk-PUQUSA6S.js";
-import "../../../../chunks/chunk-WSFCRVEQ.js";
+  ListObjectsV2Command,
+  CopyObjectCommand,
+  DeleteObjectCommand,
+  HeadObjectCommand
+} from "@aws-sdk/client-s3";
+async function moveDir3(client, bucketName, sourceDir, targetDir, options) {
+  const {
+    listObjectsOptions,
+    copyOptions,
+    deleteOptions,
+    overwrite = false
+  } = options ?? {};
+  const from = sourceDir.endsWith("/") ? sourceDir : `${sourceDir}/`;
+  const to = targetDir.endsWith("/") ? targetDir : `${targetDir}/`;
+  try {
+    let token;
+    do {
+      const listResp = await client.send(
+        new ListObjectsV2Command({
+          Bucket: bucketName,
+          Prefix: from,
+          ContinuationToken: token,
+          ...listObjectsOptions
+        })
+      );
+      for (const obj of listResp.Contents ?? []) {
+        if (obj.Key === void 0) continue;
+        const rel = obj.Key.substring(from.length);
+        const dest = `${to}${rel}`;
+        if (!overwrite) {
+          try {
+            await client.send(
+              new HeadObjectCommand({ Bucket: bucketName, Key: dest })
+            );
+            throw new Error(`Object already exists at ${dest}.`);
+          } catch (err) {
+            if (err.$metadata?.httpStatusCode !== 404 && err.name !== "NotFound")
+              throw err;
+          }
+        }
+        await client.send(
+          new CopyObjectCommand({
+            Bucket: bucketName,
+            Key: dest,
+            CopySource: `${bucketName}/${obj.Key}`,
+            ...copyOptions
+          })
+        );
+        await client.send(
+          new DeleteObjectCommand({
+            Bucket: bucketName,
+            Key: obj.Key,
+            ...deleteOptions
+          })
+        );
+      }
+      token = listResp.IsTruncated === true ? listResp.NextContinuationToken : void 0;
+    } while (token !== void 0);
+    return makeSuccess(true);
+  } catch (err) {
+    return makeFailure(unknownToString(err));
+  }
+}
+
+// src/node/@google-cloud/storage/directory/move-dir/index.ts
+async function moveDir4(bucket, sourceDir, targetDir, options) {
+  const { fileOptions, copyOptions, deleteOptions, overwrite = false } = options ?? {};
+  const from = sourceDir.endsWith("/") ? sourceDir : `${sourceDir}/`;
+  const to = targetDir.endsWith("/") ? targetDir : `${targetDir}/`;
+  try {
+    const [files] = await bucket.getFiles({ prefix: from });
+    for (const f of files) {
+      const rel = f.name.substring(from.length);
+      const dest = `${to}${rel}`;
+      const srcFile = bucket.file(f.name, fileOptions);
+      const destFile = bucket.file(dest, fileOptions);
+      if (!overwrite) {
+        const [exists] = await destFile.exists();
+        if (exists) throw new Error(`File already exists at ${dest}.`);
+      }
+      await srcFile.copy(dest, copyOptions);
+      await srcFile.delete(deleteOptions);
+    }
+    return makeSuccess(true);
+  } catch (err) {
+    return makeFailure(unknownToString(err));
+  }
+}
 
 // src/node/cloud-storage/operations/move-dir/index.ts
 async function moveDir5(client, sourcePath, targetPath, options) {

package/node/cloud-storage/operations/move-file/index.js

@@ -1,26 +1,149 @@
+// src/agnostic/misc/outcome/index.ts
+function makeSuccess(payload) {
+  return { success: true, payload };
+}
+function makeFailure(error) {
+  return { success: false, error };
+}
+
+// src/node/cloud-storage/clients/index.ts
+import { Bucket as GCSBucket } from "@google-cloud/storage";
+import { S3Client } from "@aws-sdk/client-s3";
+import { Client as FtpClient } from "basic-ftp";
+import SftpClient from "ssh2-sftp-client";
+var isGcsBucket = (client) => client instanceof GCSBucket;
+var isS3ClientWithBucket = (client) => "bucketName" in client && typeof client.bucketName === "string" && "client" in client && client.client instanceof S3Client;
+var isFtpClient = (client) => client instanceof FtpClient;
+var isSftpClient = (client) => client instanceof SftpClient;
+
+// src/agnostic/errors/unknown-to-string/index.ts
+function unknownToString(unk, encoding) {
+  if (unk instanceof Error) return unk.message;
+  if (unk instanceof Buffer) return unk.toString(encoding ?? "utf-8");
+  if (typeof unk === "string") return unk;
+  if (typeof unk === "object" && unk !== null) return JSON.stringify(unk);
+  return `${unk}`;
+}
+
+// src/node/ftps/file/move/index.ts
+async function move(ftpClient, sourcePath, targetPath, options) {
+  const {
+    ensureDir = true,
+    overwrite = false
+  } = options ?? {};
+  try {
+    if (ensureDir) {
+      const dirPath = targetPath.substring(0, targetPath.lastIndexOf("/"));
+      await ftpClient.ensureDir(dirPath);
+    }
+    if (!overwrite) {
+      try {
+        await ftpClient.size(targetPath);
+        return makeFailure(`File already exists at ${targetPath}.`);
+      } catch (err) {
+        if (err.code !== 550) {
+          return makeFailure(unknownToString(err));
+        }
+      }
+    }
+    await ftpClient.rename(sourcePath, targetPath);
+    return makeSuccess(true);
+  } catch (err) {
+    return makeFailure(unknownToString(err));
+  }
+}
+
+// src/node/sftp/file/move/index.ts
+async function move2(sftp, sourcePath, targetPath, options) {
+  const {
+    ensureDir = true,
+    overwrite = false
+  } = options ?? {};
+  try {
+    if (ensureDir) {
+      const dirPath = targetPath.substring(0, targetPath.lastIndexOf("/"));
+      await sftp.mkdir(dirPath, true);
+    }
+    if (!overwrite) {
+      const exists = await sftp.exists(targetPath) !== false;
+      if (exists) return makeFailure(`File already exists at ${targetPath}.`);
+    }
+    await sftp.rename(sourcePath, targetPath);
+    return makeSuccess(true);
+  } catch (err) {
+    return makeFailure(unknownToString(err));
+  }
+}
+
+// src/node/@aws-s3/storage/file/move/index.ts
 import {
-  move as move4
-} from "../../../../chunks/chunk-4KLCJX2T.js";
-import {
-  move as move3
-} from "../../../../chunks/chunk-LJ5MGLLU.js";
-import {
-  move as move2
-} from "../../../../chunks/chunk-EYYNCLVR.js";
-import {
-  move
-} from "../../../../chunks/chunk-WL4WNJ2Y.js";
-import {
-  isFtpClient,
-  isGcsBucket,
-  isS3ClientWithBucket,
-  isSftpClient
-} from "../../../../chunks/chunk-ISJONMNA.js";
-import {
-  makeFailure
-} from "../../../../chunks/chunk-LUAYN7VJ.js";
-import "../../../../chunks/chunk-PUQUSA6S.js";
-import "../../../../chunks/chunk-WSFCRVEQ.js";
+  HeadObjectCommand,
+  CopyObjectCommand,
+  DeleteObjectCommand
+} from "@aws-sdk/client-s3";
+async function move3(client, bucketName, sourcePath, targetPath, options) {
+  const {
+    copyOptions,
+    deleteOptions,
+    overwrite = false
+  } = options ?? {};
+  try {
+    if (!overwrite) {
+      try {
+        await client.send(new HeadObjectCommand({ Bucket: bucketName, Key: targetPath }));
+        return makeFailure(`Object already exists at ${targetPath}.`);
+      } catch (err) {
+        const notFound = err.$metadata?.httpStatusCode === 404 || err.name === "NotFound" || err.Code === "NotFound" || err.Code === "NoSuchKey";
+        if (!notFound) {
+          return makeFailure(unknownToString(err));
+        }
+      }
+    }
+    await client.send(
+      new CopyObjectCommand({
+        Bucket: bucketName,
+        Key: targetPath,
+        CopySource: `${bucketName}/${sourcePath}`,
+        ...copyOptions
+      })
+    );
+    await client.send(
+      new DeleteObjectCommand({
+        Bucket: bucketName,
+        Key: sourcePath,
+        ...deleteOptions
+      })
+    );
+    return makeSuccess(true);
+  } catch (err) {
+    return makeFailure(unknownToString(err));
+  }
+}
+
+// src/node/@google-cloud/storage/file/move/index.ts
+async function move4(bucket, sourcePath, targetPath, options) {
+  const {
+    fileOptions,
+    copyOptions,
+    deleteOptions,
+    overwrite = false
+  } = options ?? {};
+  try {
+    const srcFile = bucket.file(sourcePath, fileOptions);
+    const destFile = bucket.file(targetPath, fileOptions);
+    if (!overwrite) {
+      const [exists] = await destFile.exists();
+      if (exists) {
+        return makeFailure(`Object already exists at ${targetPath}.`);
+      }
+    }
+    await srcFile.copy(destFile, copyOptions);
+    await srcFile.delete(deleteOptions);
+    return makeSuccess(true);
+  } catch (err) {
+    return makeFailure(unknownToString(err));
+  }
+}
 
 // src/node/cloud-storage/operations/move-file/index.ts
 async function moveFile(client, sourcePath, targetPath, options) {

package/node/cloud-storage/operations/remove-dir/index.js

@@ -1,26 +1,151 @@
+// src/agnostic/misc/outcome/index.ts
+function makeSuccess(payload) {
+  return { success: true, payload };
+}
+function makeFailure(error) {
+  return { success: false, error };
+}
+
+// src/node/cloud-storage/clients/index.ts
+import { Bucket as GCSBucket } from "@google-cloud/storage";
+import { S3Client } from "@aws-sdk/client-s3";
+import { Client as FtpClient } from "basic-ftp";
+import SftpClient from "ssh2-sftp-client";
+var isGcsBucket = (client) => client instanceof GCSBucket;
+var isS3ClientWithBucket = (client) => "bucketName" in client && typeof client.bucketName === "string" && "client" in client && client.client instanceof S3Client;
+var isFtpClient = (client) => client instanceof FtpClient;
+var isSftpClient = (client) => client instanceof SftpClient;
+
+// src/agnostic/errors/unknown-to-string/index.ts
+function unknownToString(unk, encoding) {
+  if (unk instanceof Error) return unk.message;
+  if (unk instanceof Buffer) return unk.toString(encoding ?? "utf-8");
+  if (typeof unk === "string") return unk;
+  if (typeof unk === "object" && unk !== null) return JSON.stringify(unk);
+  return `${unk}`;
+}
+
+// src/node/ftps/directory/remove-dir/index.ts
+async function removeDir(ftpClient, directoryPath, options) {
+  const { ignoreMissing = true } = options ?? {};
+  async function recurse(dir) {
+    const list = await ftpClient.list(dir);
+    for (const entry of list) {
+      const full = dir.endsWith("/") ? dir + entry.name : `${dir}/${entry.name}`;
+      if (entry.isDirectory) {
+        await recurse(full);
+      } else if (entry.isFile) {
+        await ftpClient.remove(full);
+      }
+    }
+    await ftpClient.removeDir(dir);
+  }
+  try {
+    await recurse(directoryPath);
+    return makeSuccess(true);
+  } catch (err) {
+    if (ignoreMissing && err.code === 550) {
+      return makeSuccess(true);
+    }
+    return makeFailure(unknownToString(err));
+  }
+}
+
+// src/node/sftp/directory/remove-dir/index.ts
+async function removeDir2(sftp, directoryPath, options) {
+  const { ignoreMissing = true } = options ?? {};
+  async function recurse(dir) {
+    const list = await sftp.list(dir);
+    for (const entry of list) {
+      const full = dir.endsWith("/") ? dir + entry.name : `${dir}/${entry.name}`;
+      if (entry.type === "d") {
+        await recurse(full);
+      } else if (entry.type === "-") {
+        await sftp.delete(full);
+      }
+    }
+    await sftp.rmdir(dir);
+  }
+  try {
+    await recurse(directoryPath);
+    return makeSuccess(true);
+  } catch (err) {
+    if (ignoreMissing && (err.code === 2 || err.code === "ENOENT")) {
+      return makeSuccess(true);
+    }
+    return makeFailure(unknownToString(err));
+  }
+}
+
+// src/node/@aws-s3/storage/directory/remove-dir/index.ts
 import {
-  removeDir as removeDir4
-} from "../../../../chunks/chunk-GQBFMP6N.js";
-import {
-  removeDir as removeDir3
-} from "../../../../chunks/chunk-UTQNGKGQ.js";
-import {
-  removeDir as removeDir2
-} from "../../../../chunks/chunk-B6653QJD.js";
-import {
-  removeDir
-} from "../../../../chunks/chunk-FSNNEPY5.js";
-import {
-  isFtpClient,
-  isGcsBucket,
-  isS3ClientWithBucket,
-  isSftpClient
-} from "../../../../chunks/chunk-ISJONMNA.js";
-import {
-  makeFailure
-} from "../../../../chunks/chunk-LUAYN7VJ.js";
-import "../../../../chunks/chunk-PUQUSA6S.js";
-import "../../../../chunks/chunk-WSFCRVEQ.js";
+  ListObjectsV2Command,
+  DeleteObjectsCommand
+} from "@aws-sdk/client-s3";
+async function removeDir3(client, bucketName, directoryPath, options) {
+  const {
+    listObjectsOptions,
+    deleteObjectsOptions,
+    ignoreMissing = true
+  } = options ?? {};
+  const prefix = directoryPath.endsWith("/") ? directoryPath : `${directoryPath}/`;
+  let continuationToken;
+  let anyFound = false;
+  try {
+    do {
+      const listResp = await client.send(
+        new ListObjectsV2Command({
+          Bucket: bucketName,
+          Prefix: prefix,
+          ContinuationToken: continuationToken,
+          ...listObjectsOptions
+        })
+      );
+      const keys = (listResp.Contents ?? []).map((o) => o.Key).filter((e) => e !== void 0);
+      if (keys.length > 0) {
+        anyFound = true;
+        for (let i = 0; i < keys.length; i += 1e3) {
+          const chunk = keys.slice(i, i + 1e3);
+          await client.send(
+            new DeleteObjectsCommand({
+              Bucket: bucketName,
+              Delete: { Objects: chunk.map((Key) => ({ Key })) },
+              ...deleteObjectsOptions
+            })
+          );
+        }
+      }
+      continuationToken = listResp.IsTruncated === true ? listResp.NextContinuationToken : void 0;
+    } while (continuationToken !== void 0);
+    if (!anyFound && !ignoreMissing) {
+      return makeFailure(`No objects found for prefix "${prefix}".`);
+    }
+    return makeSuccess(true);
+  } catch (err) {
+    return makeFailure(unknownToString(err));
+  }
+}
+
+// src/node/@google-cloud/storage/directory/remove-dir/index.ts
+async function removeDir4(bucket, directoryPath, options) {
+  const {
+    deleteOptions,
+    ignoreMissing = true
+  } = options ?? {};
+  const prefix = directoryPath.endsWith("/") ? directoryPath : `${directoryPath}/`;
+  try {
+    if (!ignoreMissing) {
+      const [some] = await bucket.getFiles({ prefix, maxResults: 1 });
+      if (some.length === 0) {
+        return makeFailure(`No objects found for prefix "${prefix}".`);
+      }
+    }
+    await bucket.deleteFiles({ prefix, ...deleteOptions });
+    return makeSuccess(true);
+  } catch (err) {
+    return makeFailure(unknownToString(err));
+  }
+}
 
 // src/node/cloud-storage/operations/remove-dir/index.ts
 async function removeDir5(client, sourcePath, options) {

package/node/cloud-storage/operations/remove-file/index.js

@@ -1,26 +1,113 @@
+// src/agnostic/misc/outcome/index.ts
+function makeSuccess(payload) {
+  return { success: true, payload };
+}
+function makeFailure(error) {
+  return { success: false, error };
+}
+
+// src/node/cloud-storage/clients/index.ts
+import { Bucket as GCSBucket } from "@google-cloud/storage";
+import { S3Client } from "@aws-sdk/client-s3";
+import { Client as FtpClient } from "basic-ftp";
+import SftpClient from "ssh2-sftp-client";
+var isGcsBucket = (client) => client instanceof GCSBucket;
+var isS3ClientWithBucket = (client) => "bucketName" in client && typeof client.bucketName === "string" && "client" in client && client.client instanceof S3Client;
+var isFtpClient = (client) => client instanceof FtpClient;
+var isSftpClient = (client) => client instanceof SftpClient;
+
+// src/agnostic/errors/unknown-to-string/index.ts
+function unknownToString(unk, encoding) {
+  if (unk instanceof Error) return unk.message;
+  if (unk instanceof Buffer) return unk.toString(encoding ?? "utf-8");
+  if (typeof unk === "string") return unk;
+  if (typeof unk === "object" && unk !== null) return JSON.stringify(unk);
+  return `${unk}`;
+}
+
+// src/node/ftps/file/remove/index.ts
+async function remove(ftpClient, targetPath, options) {
+  const { ignoreMissing = true } = options ?? {};
+  try {
+    let fileExists = true;
+    try {
+      await ftpClient.size(targetPath);
+    } catch {
+      fileExists = false;
+    }
+    if (!fileExists) {
+      if (ignoreMissing) {
+        return makeSuccess(true);
+      }
+      return makeFailure(`File not found at ${targetPath}.`);
+    }
+    await ftpClient.remove(targetPath);
+    return makeSuccess(true);
+  } catch (err) {
+    const errStr = unknownToString(err);
+    return makeFailure(errStr);
+  }
+}
+
+// src/node/sftp/file/remove/index.ts
+async function remove2(sftp, targetPath, options) {
+  const { ignoreMissing = true } = options ?? {};
+  try {
+    const exists = await sftp.exists(targetPath) !== false;
+    if (!exists) {
+      if (ignoreMissing) return makeSuccess(true);
+      return makeFailure(`File not found at ${targetPath}.`);
+    }
+    await sftp.delete(targetPath);
+    return makeSuccess(true);
+  } catch (err) {
+    const errStr = unknownToString(err);
+    return makeFailure(errStr);
+  }
+}
+
+// src/node/@aws-s3/storage/file/remove/index.ts
 import {
-  remove as remove4
-} from "../../../../chunks/chunk-MO4TRYNI.js";
-import {
-  remove as remove3
-} from "../../../../chunks/chunk-AP3VYSVF.js";
-import {
-  remove as remove2
-} from "../../../../chunks/chunk-SYH5LYQC.js";
-import {
-  remove
-} from "../../../../chunks/chunk-5WVGUZL5.js";
-import {
-  isFtpClient,
-  isGcsBucket,
-  isS3ClientWithBucket,
-  isSftpClient
-} from "../../../../chunks/chunk-ISJONMNA.js";
-import {
-  makeFailure
-} from "../../../../chunks/chunk-LUAYN7VJ.js";
-import "../../../../chunks/chunk-PUQUSA6S.js";
-import "../../../../chunks/chunk-WSFCRVEQ.js";
+  HeadObjectCommand,
+  DeleteObjectCommand
+} from "@aws-sdk/client-s3";
+async function remove3(s3, bucketName, targetPath, options) {
+  const { ignoreMissing = true } = options ?? {};
+  try {
+    try {
+      await s3.send(new HeadObjectCommand({ Bucket: bucketName, Key: targetPath }));
+    } catch (err) {
+      const code = err?.name ?? err?.Code ?? err?.code;
+      if (code === "NotFound" || code === "NoSuchKey" || code === "NotFoundException") {
+        if (ignoreMissing) return makeSuccess(true);
+        return makeFailure(`File not found at ${targetPath}.`);
+      }
+      return makeFailure(unknownToString(err));
+    }
+    await s3.send(new DeleteObjectCommand({ Bucket: bucketName, Key: targetPath }));
+    return makeSuccess(true);
+  } catch (err) {
+    return makeFailure(unknownToString(err));
+  }
+}
+
+// src/node/@google-cloud/storage/file/remove/index.ts
+async function remove4(bucket, targetPath, options) {
+  const { fileOptions, deleteOptions, ignoreMissing = true } = options ?? {};
+  try {
+    const file = bucket.file(targetPath, fileOptions);
+    const [exists] = await file.exists();
+    if (!exists) {
+      if (ignoreMissing) return makeSuccess(true);
+      return makeFailure(`File not found at ${targetPath}.`);
+    }
+    await file.delete(deleteOptions);
+    return makeSuccess(true);
+  } catch (err) {
+    const errStr = unknownToString(err);
+    return makeFailure(errStr);
+  }
+}
 
 // src/node/cloud-storage/operations/remove-file/index.ts
 async function removeFile(client, path, options) {