backfarm 1.0.0

package/dist/utility/utilis/cloud_storage/deleteFiles.js

@@ -0,0 +1,89 @@
+import {
+  url_or_path
+} from "../../../chunk-FMCW72HO.js";
+import {
+  getKeyFromUrl
+} from "../../../chunk-SSFPGDA3.js";
+import {
+  s3Client
+} from "../../../chunk-GBXVVI2R.js";
+import "../../../chunk-IN3YY526.js";
+import {
+  ENV
+} from "../../../chunk-EWQYVPOL.js";
+import {
+  __name
+} from "../../../chunk-7QVYU63E.js";
+
+// src/utility/utilis/cloud_storage/deleteFiles.ts
+import { DeleteObjectCommand } from "@aws-sdk/client-s3";
+import * as fs from "fs";
+var deleteFiles = /* @__PURE__ */ __name(async (item_files) => {
+  if (!item_files || item_files.length === 0) {
+    return { items: [] };
+  }
+  const uniqueFiles = [...new Set(item_files)];
+  const BATCH_SIZE = 50;
+  const results = [];
+  const deleteSingleFile = /* @__PURE__ */ __name(async (item_file) => {
+    try {
+      const fileType = url_or_path(item_file);
+      if (fileType === ENV.URL) {
+        const key = getKeyFromUrl(item_file);
+        const command = new DeleteObjectCommand({
+          Bucket: ENV.BUCKET_NAME,
+          Key: key
+        });
+        await s3Client.send(command);
+        return {
+          url_or_path: item_file,
+          status: true
+        };
+      }
+      if (fileType === ENV.PATH) {
+        try {
+          await fs.promises.access(item_file);
+          await fs.promises.unlink(item_file);
+        } catch (accessError) {
+        }
+        return {
+          url_or_path: item_file,
+          status: true
+        };
+      }
+      return {
+        url_or_path: item_file,
+        status: false
+      };
+    } catch (error) {
+      return {
+        url_or_path: item_file,
+        status: false,
+        error
+      };
+    }
+  }, "deleteSingleFile");
+  for (let i = 0; i < uniqueFiles.length; i += BATCH_SIZE) {
+    const batch = uniqueFiles.slice(i, i + BATCH_SIZE);
+    const batchResults = await Promise.allSettled(
+      batch.map((file) => deleteSingleFile(file))
+    );
+    batchResults.forEach((result, index) => {
+      if (result.status === "fulfilled") {
+        results.push(result.value);
+      } else {
+        results.push({
+          url_or_path: batch[index] || "unknown",
+          // Provide fallback
+          status: false,
+          error: result.reason
+        });
+      }
+    });
+  }
+  return { items: results };
+}, "deleteFiles");
+export {
+  deleteFiles
+};
+//# sourceMappingURL=deleteFiles.js.map

package/dist/utility/utilis/cloud_storage/deleteFiles.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/utility/utilis/cloud_storage/deleteFiles.ts"],"sourcesContent":["import {ENV} from \"../../libs/env.js\";\r\nimport {url_or_path} from \"../general/file-operations.js\";\r\nimport {getKeyFromUrl} from \"../general/web.js\";\r\nimport {DeleteObjectCommand} from \"@aws-sdk/client-s3\";\r\nimport * as fs from \"node:fs\";\r\nimport type {DeleteFiles} from \"../../libs/interface.js\";\r\nimport {s3Client} from \"../../../engine/cloudBucket/r2Storage.js\";\r\n\r\nexport const deleteFiles = async (item_files: string[]): Promise<DeleteFiles> => {\r\n    // Early return for empty array\r\n    if (!item_files || item_files.length === 0) {\r\n        return { items: [] };\r\n    }\r\n\r\n    // Optional: Deduplicate files to avoid redundant operations\r\n    const uniqueFiles = [...new Set(item_files)];\r\n\r\n    // Optional: Limit concurrency to avoid overwhelming the system\r\n    const BATCH_SIZE = 50; // Adjust based on your needs\r\n    const results: DeleteFiles['items'] = [];\r\n\r\n    const deleteSingleFile = async (item_file: string): Promise<DeleteFiles['items'][0]> => {\r\n        try {\r\n            const fileType = url_or_path(item_file);\r\n\r\n            if (fileType === ENV.URL) {\r\n                const key = getKeyFromUrl(item_file);\r\n                const command = new DeleteObjectCommand({\r\n                    Bucket: ENV.BUCKET_NAME,\r\n                    Key: key,\r\n                });\r\n                await s3Client.send(command);\r\n                return {\r\n                    url_or_path: item_file,\r\n                    status: true,\r\n                };\r\n            }\r\n\r\n            if (fileType === ENV.PATH) {\r\n                try {\r\n                    await fs.promises.access(item_file);\r\n                    await fs.promises.unlink(item_file);\r\n                } catch (accessError) {\r\n                    // File doesn't exist - consider this a success (idempotent)\r\n                }\r\n                return {\r\n                    url_or_path: item_file,\r\n                    status: true,\r\n                };\r\n            }\r\n\r\n            return {\r\n                url_or_path: item_file,\r\n                status: false,\r\n            };\r\n        } catch (error) {\r\n            return {\r\n                url_or_path: item_file,\r\n                status: false,\r\n                error: error,\r\n            };\r\n        }\r\n    };\r\n\r\n    // Process in batches to control memory/connection usage\r\n    for (let i = 0; i < uniqueFiles.length; i += BATCH_SIZE) {\r\n        const batch = uniqueFiles.slice(i, i + BATCH_SIZE);\r\n        const batchResults = await Promise.allSettled(\r\n            batch.map(file => deleteSingleFile(file))\r\n        );\r\n\r\n        batchResults.forEach((result, index) => {\r\n            if (result.status === 'fulfilled') {\r\n                results.push(result.value);\r\n            } else {\r\n                // result.reason should never happen with allSettled, but handle it anyway\r\n                results.push({\r\n                    url_or_path: batch[index] || 'unknown', // Provide fallback\r\n                    status: false,\r\n                    error: result.reason,\r\n                });\r\n            }\r\n        });\r\n    }\r\n\r\n    return { items: results };\r\n};\r\n"],"mappings":";;;;;;;;;;;;;;;;;;AAGA,SAAQ,2BAA0B;AAClC,YAAY,QAAQ;AAIb,IAAM,cAAc,8BAAO,eAA+C;AAE7E,MAAI,CAAC,cAAc,WAAW,WAAW,GAAG;AACxC,WAAO,EAAE,OAAO,CAAC,EAAE;AAAA,EACvB;AAGA,QAAM,cAAc,CAAC,GAAG,IAAI,IAAI,UAAU,CAAC;AAG3C,QAAM,aAAa;AACnB,QAAM,UAAgC,CAAC;AAEvC,QAAM,mBAAmB,8BAAO,cAAwD;AACpF,QAAI;AACA,YAAM,WAAW,YAAY,SAAS;AAEtC,UAAI,aAAa,IAAI,KAAK;AACtB,cAAM,MAAM,cAAc,SAAS;AACnC,cAAM,UAAU,IAAI,oBAAoB;AAAA,UACpC,QAAQ,IAAI;AAAA,UACZ,KAAK;AAAA,QACT,CAAC;AACD,cAAM,SAAS,KAAK,OAAO;AAC3B,eAAO;AAAA,UACH,aAAa;AAAA,UACb,QAAQ;AAAA,QACZ;AAAA,MACJ;AAEA,UAAI,aAAa,IAAI,MAAM;AACvB,YAAI;AACA,gBAAS,YAAS,OAAO,SAAS;AAClC,gBAAS,YAAS,OAAO,SAAS;AAAA,QACtC,SAAS,aAAa;AAAA,QAEtB;AACA,eAAO;AAAA,UACH,aAAa;AAAA,UACb,QAAQ;AAAA,QACZ;AAAA,MACJ;AAEA,aAAO;AAAA,QACH,aAAa;AAAA,QACb,QAAQ;AAAA,MACZ;AAAA,IACJ,SAAS,OAAO;AACZ,aAAO;AAAA,QACH,aAAa;AAAA,QACb,QAAQ;AAAA,QACR;AAAA,MACJ;AAAA,IACJ;AAAA,EACJ,GAzCyB;AA4CzB,WAAS,IAAI,GAAG,IAAI,YAAY,QAAQ,KAAK,YAAY;AACrD,UAAM,QAAQ,YAAY,MAAM,GAAG,IAAI,UAAU;AACjD,UAAM,eAAe,MAAM,QAAQ;AAAA,MAC/B,MAAM,IAAI,UAAQ,iBAAiB,IAAI,CAAC;AAAA,IAC5C;AAEA,iBAAa,QAAQ,CAAC,QAAQ,UAAU;AACpC,UAAI,OAAO,WAAW,aAAa;AAC/B,gBAAQ,KAAK,OAAO,KAAK;AAAA,MAC7B,OAAO;AAEH,gBAAQ,KAAK;AAAA,UACT,aAAa,MAAM,KAAK,KAAK;AAAA;AAAA,UAC7B,QAAQ;AAAA,UACR,OAAO,OAAO;AAAA,QAClB,CAAC;AAAA,MACL;AAAA,IACJ,CAAC;AAAA,EACL;AAEA,SAAO,EAAE,OAAO,QAAQ;AAC5B,GA9E2B;","names":[]}

package/dist/utility/utilis/cloud_storage/downloadFile.d.ts

@@ -0,0 +1,9 @@
+import { DownloadFileParams, DownloadedFile } from '../../libs/interface.js';
+import 'mongodb';
+import '../../libs/types.js';
+import 'express';
+import '../../libs/env.js';
+
+declare const downloadFile: ({ url, outputPath, }: DownloadFileParams) => Promise<DownloadedFile>;
+
+export { downloadFile };

package/dist/utility/utilis/cloud_storage/downloadFile.js

@@ -0,0 +1,74 @@
+import {
+  downloadedFilePath,
+  getFileExtension
+} from "../../../chunk-FMCW72HO.js";
+import {
+  generateUniqueValue
+} from "../../../chunk-X3R3RLXY.js";
+import {
+  getKeyFromUrl
+} from "../../../chunk-SSFPGDA3.js";
+import {
+  s3Client
+} from "../../../chunk-GBXVVI2R.js";
+import "../../../chunk-IN3YY526.js";
+import {
+  ENV
+} from "../../../chunk-EWQYVPOL.js";
+import {
+  __name
+} from "../../../chunk-7QVYU63E.js";
+
+// src/utility/utilis/cloud_storage/downloadFile.ts
+import { GetObjectCommand } from "@aws-sdk/client-s3";
+import { pipeline } from "stream/promises";
+import path from "path";
+import fsPromises from "fs/promises";
+import * as fs from "fs";
+var downloadFile = /* @__PURE__ */ __name(async ({
+  url,
+  outputPath
+}) => {
+  try {
+    const key = getKeyFromUrl(url);
+    const command = new GetObjectCommand({
+      Bucket: ENV.BUCKET_NAME,
+      Key: key
+    });
+    const response = await s3Client.send(command);
+    if (!response.Body) {
+      console.log(response);
+      return {
+        status: true,
+        url,
+        error: new Error(`Empty response body received for key: ${key}`)
+      };
+    }
+    const fileExtension = getFileExtension(url);
+    const fileName = generateUniqueValue(16);
+    const finalFileName = `${fileName}.${fileExtension}`;
+    const targetPath = downloadedFilePath({ path: outputPath || [], fileName: finalFileName });
+    const dir = path.dirname(targetPath);
+    if (!fs.existsSync(dir)) {
+      await fsPromises.mkdir(dir, { recursive: true });
+    }
+    const stream = response.Body;
+    await pipeline(stream, fs.createWriteStream(targetPath));
+    return {
+      status: true,
+      url,
+      path: targetPath
+    };
+  } catch (error) {
+    console.error(error);
+    return {
+      status: false,
+      url,
+      error: error instanceof Error ? error : new Error(String(error))
+    };
+  }
+}, "downloadFile");
+export {
+  downloadFile
+};
+//# sourceMappingURL=downloadFile.js.map

package/dist/utility/utilis/cloud_storage/downloadFile.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/utility/utilis/cloud_storage/downloadFile.ts"],"sourcesContent":["import {GetObjectCommand} from \"@aws-sdk/client-s3\";\r\nimport {getKeyFromUrl} from \"../general/web.js\";\r\nimport { pipeline } from \"stream/promises\";\r\nimport path from 'node:path'\r\nimport fsPromises from 'fs/promises';\r\nimport * as fs from \"node:fs\";\r\nimport type {DownloadedFile, DownloadFileParams} from \"../../libs/interface.js\";\r\nimport {ENV} from \"../../libs/env.js\";\r\nimport {downloadedFilePath, getFileExtension} from \"../general/file-operations.js\";\r\nimport {generateUniqueValue} from \"../general/uuids.js\";\r\nimport {s3Client} from \"../../../engine/cloudBucket/r2Storage.js\";\r\n\r\n\r\n\r\nexport const downloadFile = async ({\r\n                                       url,\r\n                                       outputPath,\r\n                                   }: DownloadFileParams): Promise<DownloadedFile> => {\r\n    try {\r\n        const key = getKeyFromUrl(url);\r\n\r\n        const command = new GetObjectCommand({\r\n            Bucket: ENV.BUCKET_NAME,\r\n            Key: key,\r\n        });\r\n\r\n        const response = await s3Client.send(command);\r\n\r\n        if (!response.Body) {\r\n            console.log(response);\r\n            return {\r\n                status: true,\r\n                url: url,\r\n                error: new Error(`Empty response body received for key: ${key}`),\r\n            };\r\n        }\r\n\r\n        const fileExtension = getFileExtension(url);\r\n        const fileName = generateUniqueValue(16);\r\n        const finalFileName = `${fileName}.${fileExtension}`;\r\n        const targetPath = downloadedFilePath({ path: outputPath || [], fileName: finalFileName });\r\n\r\n        // Ensure directory structure exists for targetPath\r\n        const dir = path.dirname(targetPath);\r\n        if (!fs.existsSync(dir)) {\r\n            await fsPromises.mkdir(dir, { recursive: true });\r\n        }\r\n\r\n        // Cast stream to NodeJS.ReadableStream for pipeline overload\r\n        const stream = response.Body as NodeJS.ReadableStream;\r\n        await pipeline(stream, fs.createWriteStream(targetPath));\r\n\r\n        return {\r\n            status: true,\r\n            url: url,\r\n            path: targetPath,\r\n        };\r\n\r\n    } catch (error) {\r\n        console.error(error);\r\n        return {\r\n            status: false,\r\n            url: url,\r\n            error: error instanceof Error ? error : new Error(String(error)),\r\n        };\r\n    }\r\n};\r\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAAA,SAAQ,wBAAuB;AAE/B,SAAS,gBAAgB;AACzB,OAAO,UAAU;AACjB,OAAO,gBAAgB;AACvB,YAAY,QAAQ;AASb,IAAM,eAAe,8BAAO;AAAA,EACI;AAAA,EACA;AACJ,MAAmD;AAClF,MAAI;AACA,UAAM,MAAM,cAAc,GAAG;AAE7B,UAAM,UAAU,IAAI,iBAAiB;AAAA,MACjC,QAAQ,IAAI;AAAA,MACZ,KAAK;AAAA,IACT,CAAC;AAED,UAAM,WAAW,MAAM,SAAS,KAAK,OAAO;AAE5C,QAAI,CAAC,SAAS,MAAM;AAChB,cAAQ,IAAI,QAAQ;AACpB,aAAO;AAAA,QACH,QAAQ;AAAA,QACR;AAAA,QACA,OAAO,IAAI,MAAM,yCAAyC,GAAG,EAAE;AAAA,MACnE;AAAA,IACJ;AAEA,UAAM,gBAAgB,iBAAiB,GAAG;AAC1C,UAAM,WAAW,oBAAoB,EAAE;AACvC,UAAM,gBAAgB,GAAG,QAAQ,IAAI,aAAa;AAClD,UAAM,aAAa,mBAAmB,EAAE,MAAM,cAAc,CAAC,GAAG,UAAU,cAAc,CAAC;AAGzF,UAAM,MAAM,KAAK,QAAQ,UAAU;AACnC,QAAI,CAAI,cAAW,GAAG,GAAG;AACrB,YAAM,WAAW,MAAM,KAAK,EAAE,WAAW,KAAK,CAAC;AAAA,IACnD;AAGA,UAAM,SAAS,SAAS;AACxB,UAAM,SAAS,QAAW,qBAAkB,UAAU,CAAC;AAEvD,WAAO;AAAA,MACH,QAAQ;AAAA,MACR;AAAA,MACA,MAAM;AAAA,IACV;AAAA,EAEJ,SAAS,OAAO;AACZ,YAAQ,MAAM,KAAK;AACnB,WAAO;AAAA,MACH,QAAQ;AAAA,MACR;AAAA,MACA,OAAO,iBAAiB,QAAQ,QAAQ,IAAI,MAAM,OAAO,KAAK,CAAC;AAAA,IACnE;AAAA,EACJ;AACJ,GApD4B;","names":[]}

package/dist/utility/utilis/cloud_storage/downloadFiles.d.ts

@@ -0,0 +1,9 @@
+import { DownloadFilesParams, DownloadedFile } from '../../libs/interface.js';
+import 'mongodb';
+import '../../libs/types.js';
+import 'express';
+import '../../libs/env.js';
+
+declare const downloadFiles: ({ files, globalPath, }: DownloadFilesParams) => Promise<DownloadedFile[]>;
+
+export { downloadFiles };

package/dist/utility/utilis/cloud_storage/downloadFiles.js

@@ -0,0 +1,88 @@
+import {
+  downloadedFilePath,
+  getFileExtension
+} from "../../../chunk-FMCW72HO.js";
+import {
+  generateUniqueValue
+} from "../../../chunk-X3R3RLXY.js";
+import {
+  getKeyFromUrl
+} from "../../../chunk-SSFPGDA3.js";
+import {
+  s3Client
+} from "../../../chunk-GBXVVI2R.js";
+import "../../../chunk-IN3YY526.js";
+import {
+  ENV
+} from "../../../chunk-EWQYVPOL.js";
+import {
+  __name
+} from "../../../chunk-7QVYU63E.js";
+
+// src/utility/utilis/cloud_storage/downloadFiles.ts
+import { GetObjectCommand } from "@aws-sdk/client-s3";
+import path from "path";
+import fsPromises from "fs/promises";
+import * as fs from "fs";
+import { pipeline } from "stream/promises";
+var downloadFiles = /* @__PURE__ */ __name(async ({
+  files,
+  globalPath
+}) => {
+  const hasIndividualOutputPath = files.some(
+    (file) => file.outputPath && file.outputPath.length > 0
+  );
+  if (globalPath && hasIndividualOutputPath) {
+    throw new Error(
+      "Conflict: Cannot specify both 'globalPath' and individual 'outputPath' on files."
+    );
+  }
+  const downloadPromises = files.map(async (file) => {
+    const { url, outputPath } = file;
+    try {
+      const key = getKeyFromUrl(url);
+      const command = new GetObjectCommand({
+        Bucket: ENV.BUCKET_NAME,
+        Key: key
+      });
+      const response = await s3Client.send(command);
+      if (!response.Body) {
+        return {
+          status: false,
+          url,
+          error: new Error(`Empty response body received for key: ${key}`)
+        };
+      }
+      const fileExtension = getFileExtension(url);
+      const fileName = generateUniqueValue(16);
+      const finalFileName = `${fileName}.${fileExtension}`;
+      const resolvedPathSegments = outputPath || (globalPath ? [globalPath] : []);
+      const targetPath = downloadedFilePath({
+        path: resolvedPathSegments,
+        fileName: finalFileName
+      });
+      const dir = path.dirname(targetPath);
+      if (!fs.existsSync(dir)) {
+        await fsPromises.mkdir(dir, { recursive: true });
+      }
+      const stream = response.Body;
+      await pipeline(stream, fs.createWriteStream(targetPath));
+      return {
+        status: true,
+        url,
+        path: targetPath
+      };
+    } catch (error) {
+      return {
+        status: false,
+        url,
+        error: error instanceof Error ? error : new Error(String(error))
+      };
+    }
+  });
+  return Promise.all(downloadPromises);
+}, "downloadFiles");
+export {
+  downloadFiles
+};
+//# sourceMappingURL=downloadFiles.js.map

package/dist/utility/utilis/cloud_storage/downloadFiles.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/utility/utilis/cloud_storage/downloadFiles.ts"],"sourcesContent":["import type {DownloadedFile, DownloadFilesParams} from \"../../libs/interface.js\";\r\nimport {getKeyFromUrl} from \"../general/web.js\";\r\nimport {GetObjectCommand} from \"@aws-sdk/client-s3\";\r\nimport {ENV} from \"../../libs/env.js\";\r\nimport {downloadedFilePath, getFileExtension} from \"../general/file-operations.js\";\r\nimport path from \"node:path\";\r\nimport fsPromises from \"fs/promises\";\r\nimport * as fs from \"node:fs\";\r\nimport {pipeline} from \"stream/promises\";\r\nimport {generateUniqueValue} from \"../general/uuids.js\";\r\nimport {s3Client} from \"../../../engine/cloudBucket/r2Storage.js\";\r\n\r\nexport const downloadFiles = async ({\r\n                                        files,\r\n                                        globalPath,\r\n                                    }: DownloadFilesParams): Promise<DownloadedFile[]> => {\r\n    // 1. Validate path conflict rule upfront\r\n    const hasIndividualOutputPath = files.some(\r\n        (file) => file.outputPath && file.outputPath.length > 0\r\n    );\r\n\r\n    if (globalPath && hasIndividualOutputPath) {\r\n        throw new Error(\r\n            \"Conflict: Cannot specify both 'globalPath' and individual 'outputPath' on files.\"\r\n        );\r\n    }\r\n\r\n    // 2. Process all files independently in parallel\r\n    const downloadPromises = files.map(async (file): Promise<DownloadedFile> => {\r\n        const { url, outputPath } = file;\r\n\r\n        try {\r\n            const key = getKeyFromUrl(url);\r\n\r\n            const command = new GetObjectCommand({\r\n                Bucket: ENV.BUCKET_NAME,\r\n                Key: key,\r\n            });\r\n\r\n            const response = await s3Client.send(command);\r\n\r\n            if (!response.Body) {\r\n                return {\r\n                    status: false,\r\n                    url: url,\r\n                    error: new Error(`Empty response body received for key: ${key}`),\r\n                };\r\n            }\r\n\r\n            const fileExtension = getFileExtension(url);\r\n            const fileName = generateUniqueValue(16);\r\n            const finalFileName = `${fileName}.${fileExtension}`;\r\n\r\n            // Resolve target path using either file's outputPath or globalPath\r\n            const resolvedPathSegments = outputPath || (globalPath ? [globalPath] : []);\r\n            const targetPath = downloadedFilePath({\r\n                path: resolvedPathSegments,\r\n                fileName: finalFileName,\r\n            });\r\n\r\n            // Ensure output folder structure exists\r\n            const dir = path.dirname(targetPath);\r\n            if (!fs.existsSync(dir)) {\r\n                await fsPromises.mkdir(dir, { recursive: true });\r\n            }\r\n\r\n            // Stream response body directly to file\r\n            const stream = response.Body as NodeJS.ReadableStream;\r\n            await pipeline(stream, fs.createWriteStream(targetPath));\r\n\r\n            return {\r\n                status: true,\r\n                url: url,\r\n                path: targetPath,\r\n            };\r\n        } catch (error) {\r\n            return {\r\n                status: false,\r\n                url: url,\r\n                error: error instanceof Error ? error : new Error(String(error)),\r\n            };\r\n        }\r\n    });\r\n\r\n    return Promise.all(downloadPromises);\r\n};\r\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAEA,SAAQ,wBAAuB;AAG/B,OAAO,UAAU;AACjB,OAAO,gBAAgB;AACvB,YAAY,QAAQ;AACpB,SAAQ,gBAAe;AAIhB,IAAM,gBAAgB,8BAAO;AAAA,EACI;AAAA,EACA;AACJ,MAAsD;AAEtF,QAAM,0BAA0B,MAAM;AAAA,IAClC,CAAC,SAAS,KAAK,cAAc,KAAK,WAAW,SAAS;AAAA,EAC1D;AAEA,MAAI,cAAc,yBAAyB;AACvC,UAAM,IAAI;AAAA,MACN;AAAA,IACJ;AAAA,EACJ;AAGA,QAAM,mBAAmB,MAAM,IAAI,OAAO,SAAkC;AACxE,UAAM,EAAE,KAAK,WAAW,IAAI;AAE5B,QAAI;AACA,YAAM,MAAM,cAAc,GAAG;AAE7B,YAAM,UAAU,IAAI,iBAAiB;AAAA,QACjC,QAAQ,IAAI;AAAA,QACZ,KAAK;AAAA,MACT,CAAC;AAED,YAAM,WAAW,MAAM,SAAS,KAAK,OAAO;AAE5C,UAAI,CAAC,SAAS,MAAM;AAChB,eAAO;AAAA,UACH,QAAQ;AAAA,UACR;AAAA,UACA,OAAO,IAAI,MAAM,yCAAyC,GAAG,EAAE;AAAA,QACnE;AAAA,MACJ;AAEA,YAAM,gBAAgB,iBAAiB,GAAG;AAC1C,YAAM,WAAW,oBAAoB,EAAE;AACvC,YAAM,gBAAgB,GAAG,QAAQ,IAAI,aAAa;AAGlD,YAAM,uBAAuB,eAAe,aAAa,CAAC,UAAU,IAAI,CAAC;AACzE,YAAM,aAAa,mBAAmB;AAAA,QAClC,MAAM;AAAA,QACN,UAAU;AAAA,MACd,CAAC;AAGD,YAAM,MAAM,KAAK,QAAQ,UAAU;AACnC,UAAI,CAAI,cAAW,GAAG,GAAG;AACrB,cAAM,WAAW,MAAM,KAAK,EAAE,WAAW,KAAK,CAAC;AAAA,MACnD;AAGA,YAAM,SAAS,SAAS;AACxB,YAAM,SAAS,QAAW,qBAAkB,UAAU,CAAC;AAEvD,aAAO;AAAA,QACH,QAAQ;AAAA,QACR;AAAA,QACA,MAAM;AAAA,MACV;AAAA,IACJ,SAAS,OAAO;AACZ,aAAO;AAAA,QACH,QAAQ;AAAA,QACR;AAAA,QACA,OAAO,iBAAiB,QAAQ,QAAQ,IAAI,MAAM,OAAO,KAAK,CAAC;AAAA,MACnE;AAAA,IACJ;AAAA,EACJ,CAAC;AAED,SAAO,QAAQ,IAAI,gBAAgB;AACvC,GAzE6B;","names":[]}

package/dist/utility/utilis/cloud_storage/s3Client.d.ts

@@ -0,0 +1,5 @@
+import { S3Client } from '@aws-sdk/client-s3';
+
+declare const getS3Client: () => Promise<S3Client>;
+
+export { getS3Client };

package/dist/utility/utilis/cloud_storage/s3Client.js

@@ -0,0 +1,17 @@
+import {
+  s3Client
+} from "../../../chunk-GBXVVI2R.js";
+import "../../../chunk-IN3YY526.js";
+import "../../../chunk-EWQYVPOL.js";
+import {
+  __name
+} from "../../../chunk-7QVYU63E.js";
+
+// src/utility/utilis/cloud_storage/s3Client.ts
+var getS3Client = /* @__PURE__ */ __name(async () => {
+  return s3Client;
+}, "getS3Client");
+export {
+  getS3Client
+};
+//# sourceMappingURL=s3Client.js.map

package/dist/utility/utilis/cloud_storage/s3Client.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/utility/utilis/cloud_storage/s3Client.ts"],"sourcesContent":["import {s3Client as sss} from \"../../../engine/cloudBucket/r2Storage.js\";\r\nimport type {S3Client} from \"@aws-sdk/client-s3\";\r\n\r\nexport const getS3Client = async (): Promise<S3Client> => {\r\n    return sss;\r\n}\r\n"],"mappings":";;;;;;;;;;AAGO,IAAM,cAAc,mCAA+B;AACtD,SAAO;AACX,GAF2B;","names":[]}

package/dist/utility/utilis/cloud_storage/uploadFile.d.ts

@@ -0,0 +1,51 @@
+import { UploadFileInput } from '../../libs/interface.js';
+import { FileUploadedResponseData } from '../../libs/types.js';
+import 'mongodb';
+import 'express';
+import '../../libs/env.js';
+
+/**
+ * Uploads a single file to the configured S3-compatible storage bucket.
+ *
+ * The function accepts a Multer file, Web API `File`, raw `Buffer`, or file
+ * path/URL. A unique file name is generated while preserving the original
+ * file extension. The file is then converted to a byte array, its content
+ * type is detected, and it is uploaded to the configured bucket.
+ *
+ * On successful upload, the function returns the generated storage path and
+ * public URL along with the original file data when applicable. If the upload
+ * fails, it returns the encountered error and the original file data when
+ * available.
+ *
+ * @param params - The file and optional storage path used for the upload.
+ * @param params.file - The file, buffer, or file path/URL to upload.
+ * @param params.path - Optional array of path segments under which the file
+ * should be stored.
+ * @returns A promise resolving to a `FileUploadedResponseData` containing
+ * either the uploaded file information or the encountered error.
+ *
+ * @example
+ * const result = await upload_file({
+ *     file: req.file,
+ *     path: ['temporary_files'],
+ * });
+ *
+ * if ('error' in result) {
+ *     console.error('Upload failed:', result.error);
+ * } else {
+ *     console.log('File uploaded:', result.url);
+ * }
+ *
+ * @example
+ * const result = await upload_file({
+ *     file: buffer,
+ *     path: ['documents', 'reports'],
+ * });
+ *
+ * if (!result.error) {
+ *     console.log('Uploaded to:', result.path);
+ * }
+ */
+declare const upload_file: ({ file, path }: UploadFileInput) => Promise<FileUploadedResponseData>;
+
+export { upload_file };

package/dist/utility/utilis/cloud_storage/uploadFile.js

@@ -0,0 +1,14 @@
+import {
+  upload_file
+} from "../../../chunk-I6VD2JKM.js";
+import "../../../chunk-FMCW72HO.js";
+import "../../../chunk-X3R3RLXY.js";
+import "../../../chunk-SSFPGDA3.js";
+import "../../../chunk-GBXVVI2R.js";
+import "../../../chunk-IN3YY526.js";
+import "../../../chunk-EWQYVPOL.js";
+import "../../../chunk-7QVYU63E.js";
+export {
+  upload_file
+};
+//# sourceMappingURL=uploadFile.js.map

package/dist/utility/utilis/cloud_storage/uploadFile.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/utility/utilis/cloud_storage/uploadFiles.d.ts

@@ -0,0 +1,73 @@
+import { UploadFilesInput, FilesUploadedResponseData } from '../../libs/interface.js';
+import 'mongodb';
+import '../../libs/types.js';
+import 'express';
+import '../../libs/env.js';
+
+/**
+ * Uploads multiple files to the configured S3-compatible storage bucket
+ * concurrently with a configurable concurrency limit.
+ *
+ * Each file is uploaded using the `upload_file` function. A global path can
+ * be applied to all files, or each file can specify its own individual path,
+ * but both options cannot be used at the same time.
+ *
+ * Failed uploads are collected separately from successful uploads, allowing
+ * the caller to inspect the result of every individual file without stopping
+ * the entire batch operation.
+ *
+ * @param params - Configuration options for the batch upload.
+ * @param params.files - The files to upload along with their optional paths.
+ * @param params.globalPath - An optional path applied to all files that do
+ * not specify an individual path.
+ * @param params.concurrency - The maximum number of files uploaded
+ * concurrently. Defaults to `5`.
+ * @returns A promise resolving to a `FilesUploadedResponseData` containing
+ * separate arrays of successfully uploaded and failed files.
+ * @throws {Error} If both `globalPath` and an individual file `path` are
+ * provided.
+ *
+ * @example
+ * const result = await upload_files({
+ *     files: [
+ *         { file: file1 },
+ *         { file: file2 },
+ *         { file: file3 },
+ *     ],
+ *     globalPath: ['temporary_files'],
+ *     concurrency: 5,
+ * });
+ *
+ * console.log('Successful uploads:', result.successFiles);
+ * console.log('Failed uploads:', result.failedFiles);
+ *
+ * @example
+ * const result = await upload_files({
+ *     files: [
+ *         {
+ *             file: file1,
+ *             path: ['documents', 'reports'],
+ *         },
+ *         {
+ *             file: file2,
+ *             path: ['documents', 'images'],
+ *         },
+ *     ],
+ *     concurrency: 10,
+ * });
+ *
+ * @example
+ * // This throws because globalPath and an individual path cannot be used together.
+ * const result = await upload_files({
+ *     files: [
+ *         {
+ *             file: file1,
+ *             path: ['documents'],
+ *         },
+ *     ],
+ *     globalPath: ['temporary_files'],
+ * });
+ */
+declare const upload_files: ({ files, globalPath, concurrency }: UploadFilesInput) => Promise<FilesUploadedResponseData>;
+
+export { upload_files };

package/dist/utility/utilis/cloud_storage/uploadFiles.js

@@ -0,0 +1,49 @@
+import {
+  upload_file
+} from "../../../chunk-I6VD2JKM.js";
+import "../../../chunk-FMCW72HO.js";
+import "../../../chunk-X3R3RLXY.js";
+import "../../../chunk-SSFPGDA3.js";
+import "../../../chunk-GBXVVI2R.js";
+import "../../../chunk-IN3YY526.js";
+import "../../../chunk-EWQYVPOL.js";
+import {
+  __name
+} from "../../../chunk-7QVYU63E.js";
+
+// src/utility/utilis/cloud_storage/uploadFiles.ts
+import pLimit from "p-limit";
+var upload_files = /* @__PURE__ */ __name(async ({
+  files,
+  globalPath,
+  concurrency = 5
+}) => {
+  if (globalPath && files.some((item) => item.path && item.path.length > 0)) {
+    throw new Error("Invalid options: 'globalPath' and individual 'path' cannot both exist.");
+  }
+  const limiter = pLimit(concurrency);
+  const returnData = {
+    successFiles: [],
+    failedFiles: []
+  };
+  const uploadTasks = files.map(
+    ({ file, path }) => limiter(async () => {
+      const resolvedPath = path ?? (globalPath?.length ? globalPath : void 0);
+      const result = await upload_file({
+        file,
+        path: resolvedPath
+      });
+      if ("error" in result && result.error) {
+        returnData.failedFiles.push(result);
+      } else {
+        returnData.successFiles.push(result);
+      }
+    })
+  );
+  await Promise.all(uploadTasks);
+  return returnData;
+}, "upload_files");
+export {
+  upload_files
+};
+//# sourceMappingURL=uploadFiles.js.map

package/dist/utility/utilis/cloud_storage/uploadFiles.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/utility/utilis/cloud_storage/uploadFiles.ts"],"sourcesContent":["import type {FilesUploadedResponseData, UploadFilesInput} from \"../../libs/interface.js\";\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\nimport pLimit from 'p-limit';\r\nimport {upload_file} from \"./uploadFile.js\";\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n/**\r\n * Uploads multiple files to the configured S3-compatible storage bucket\r\n * concurrently with a configurable concurrency limit.\r\n *\r\n * Each file is uploaded using the `upload_file` function. A global path can\r\n * be applied to all files, or each file can specify its own individual path,\r\n * but both options cannot be used at the same time.\r\n *\r\n * Failed uploads are collected separately from successful uploads, allowing\r\n * the caller to inspect the result of every individual file without stopping\r\n * the entire batch operation.\r\n *\r\n * @param params - Configuration options for the batch upload.\r\n * @param params.files - The files to upload along with their optional paths.\r\n * @param params.globalPath - An optional path applied to all files that do\r\n * not specify an individual path.\r\n * @param params.concurrency - The maximum number of files uploaded\r\n * concurrently. Defaults to `5`.\r\n * @returns A promise resolving to a `FilesUploadedResponseData` containing\r\n * separate arrays of successfully uploaded and failed files.\r\n * @throws {Error} If both `globalPath` and an individual file `path` are\r\n * provided.\r\n *\r\n * @example\r\n * const result = await upload_files({\r\n *     files: [\r\n *         { file: file1 },\r\n *         { file: file2 },\r\n *         { file: file3 },\r\n *     ],\r\n *     globalPath: ['temporary_files'],\r\n *     concurrency: 5,\r\n * });\r\n *\r\n * console.log('Successful uploads:', result.successFiles);\r\n * console.log('Failed uploads:', result.failedFiles);\r\n *\r\n * @example\r\n * const result = await upload_files({\r\n *     files: [\r\n *         {\r\n *             file: file1,\r\n *             path: ['documents', 'reports'],\r\n *         },\r\n *         {\r\n *             file: file2,\r\n *             path: ['documents', 'images'],\r\n *         },\r\n *     ],\r\n *     concurrency: 10,\r\n * });\r\n *\r\n * @example\r\n * // This throws because globalPath and an individual path cannot be used together.\r\n * const result = await upload_files({\r\n *     files: [\r\n *         {\r\n *             file: file1,\r\n *             path: ['documents'],\r\n *         },\r\n *     ],\r\n *     globalPath: ['temporary_files'],\r\n * });\r\n */\r\nexport const upload_files = async ({\r\n                                       files,\r\n                                       globalPath,\r\n                                       concurrency = 5\r\n                                   }: UploadFilesInput): Promise<FilesUploadedResponseData> => {\r\n\r\n    // 1. Validate: Throw error immediately if globalPath coexists with any item's individual path\r\n    if (globalPath && files.some((item) => item.path && item.path.length > 0)) {\r\n        throw new Error(\"Invalid options: 'globalPath' and individual 'path' cannot both exist.\");\r\n    }\r\n\r\n    const limiter = pLimit(concurrency);\r\n    const returnData: FilesUploadedResponseData = {\r\n        successFiles: [],\r\n        failedFiles: []\r\n    };\r\n\r\n    // 2. Map and run concurrent uploads inside limiter tasks\r\n    const uploadTasks = files.map(({ file, path }) =>\r\n        limiter(async () => {\r\n            // Resolve target path (use item's path if available, otherwise globalPath array)\r\n            const resolvedPath = path ?? (globalPath?.length ? globalPath : undefined);\r\n\r\n            // Delegate single file upload logic to upload_file function\r\n            const result = await upload_file({\r\n                file,\r\n                path: resolvedPath\r\n            });\r\n\r\n            // Aggregate results based on whether an error occurred on the single file upload\r\n            if ('error' in result && result.error) {\r\n                returnData.failedFiles.push(result);\r\n            } else {\r\n                returnData.successFiles.push(result);\r\n            }\r\n        })\r\n    );\r\n\r\n    // 3. Wait for all concurrent uploads to settle\r\n    await Promise.all(uploadTasks);\r\n\r\n    return returnData;\r\n};\r\n"],"mappings":";;;;;;;;;;;;;;AAQA,OAAO,YAAY;AAyEZ,IAAM,eAAe,8BAAO;AAAA,EACI;AAAA,EACA;AAAA,EACA,cAAc;AAClB,MAA4D;AAG3F,MAAI,cAAc,MAAM,KAAK,CAAC,SAAS,KAAK,QAAQ,KAAK,KAAK,SAAS,CAAC,GAAG;AACvE,UAAM,IAAI,MAAM,wEAAwE;AAAA,EAC5F;AAEA,QAAM,UAAU,OAAO,WAAW;AAClC,QAAM,aAAwC;AAAA,IAC1C,cAAc,CAAC;AAAA,IACf,aAAa,CAAC;AAAA,EAClB;AAGA,QAAM,cAAc,MAAM;AAAA,IAAI,CAAC,EAAE,MAAM,KAAK,MACxC,QAAQ,YAAY;AAEhB,YAAM,eAAe,SAAS,YAAY,SAAS,aAAa;AAGhE,YAAM,SAAS,MAAM,YAAY;AAAA,QAC7B;AAAA,QACA,MAAM;AAAA,MACV,CAAC;AAGD,UAAI,WAAW,UAAU,OAAO,OAAO;AACnC,mBAAW,YAAY,KAAK,MAAM;AAAA,MACtC,OAAO;AACH,mBAAW,aAAa,KAAK,MAAM;AAAA,MACvC;AAAA,IACJ,CAAC;AAAA,EACL;AAGA,QAAM,QAAQ,IAAI,WAAW;AAE7B,SAAO;AACX,GA1C4B;","names":[]}

package/dist/utility/utilis/general/error_handler.d.ts

@@ -0,0 +1,31 @@
+import { CustomErrorTemplate } from '../../libs/interface.js';
+import 'mongodb';
+import '../../libs/types.js';
+import 'express';
+import '../../libs/env.js';
+
+/**
+ * Normalizes and logs an error with optional contextual information.
+ *
+ * Formats the error for both terminal and browser environments, displaying
+ * its type, message, timestamp, context, stack trace, and raw error object.
+ * The normalized error is returned after being logged.
+ *
+ * @param err - The unknown error value to normalize and handle.
+ * @param context - Optional context describing where the error occurred.
+ * @returns The normalized error as a `CustomErrorTemplate`.
+ *
+ * @example
+ * const error = handleError(error, 'File Upload');
+ * // Logs the normalized error and returns a CustomErrorTemplate.
+ *
+ * @example
+ * try {
+ *     await upload_file(file);
+ * } catch (error) {
+ *     handleError(error, 'MinIO Upload');
+ * }
+ */
+declare function handleError(err: unknown, context?: string): CustomErrorTemplate;
+
+export { handleError };

package/dist/utility/utilis/general/error_handler.js

@@ -0,0 +1,8 @@
+import {
+  handleError
+} from "../../../chunk-P5XJG7OG.js";
+import "../../../chunk-7QVYU63E.js";
+export {
+  handleError
+};
+//# sourceMappingURL=error_handler.js.map

package/dist/utility/utilis/general/error_handler.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}