backfarm 1.0.4 → 1.0.6

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

@@ -1,86 +1,12 @@
 import {
-  generateUniqueValue
-} from "../../../chunk-X3R3RLXY.js";
-import {
-  getKeyFromUrl
-} from "../../../chunk-SSFPGDA3.js";
-import {
-  s3Client
-} from "../../../chunk-YTBSGKGF.js";
-import {
-  downloadedFilePath,
-  getFileExtension
-} from "../../../chunk-W3W3X2OE.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");
+  downloadFiles
+} from "../../../chunk-452DWS46.js";
+import "../../../chunk-IZEPCXYK.js";
+import "../../../chunk-ZC33GE2U.js";
+import "../../../chunk-J3P6W53K.js";
+import "../../../chunk-QW2GGDEG.js";
+import "../../../chunk-LE2SDA4O.js";
+import "../../../chunk-7QVYU63E.js";
 export {
   downloadFiles
 };

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

@@ -1 +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":[]}
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

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

@@ -1,11 +1,11 @@
 import {
   upload_file
-} from "../../../chunk-ZMDJ45KH.js";
-import "../../../chunk-X3R3RLXY.js";
-import "../../../chunk-SSFPGDA3.js";
-import "../../../chunk-YTBSGKGF.js";
-import "../../../chunk-W3W3X2OE.js";
-import "../../../chunk-EWQYVPOL.js";
+} from "../../../chunk-ZGOMCU4T.js";
+import "../../../chunk-IZEPCXYK.js";
+import "../../../chunk-ZC33GE2U.js";
+import "../../../chunk-J3P6W53K.js";
+import "../../../chunk-QW2GGDEG.js";
+import "../../../chunk-LE2SDA4O.js";
 import "../../../chunk-7QVYU63E.js";
 export {
   upload_file

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

@@ -4,70 +4,6 @@ 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

@@ -1,47 +1,13 @@
 import {
-  upload_file
-} from "../../../chunk-ZMDJ45KH.js";
-import "../../../chunk-X3R3RLXY.js";
-import "../../../chunk-SSFPGDA3.js";
-import "../../../chunk-YTBSGKGF.js";
-import "../../../chunk-W3W3X2OE.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");
+  upload_files
+} from "../../../chunk-O2ZDXQ2Z.js";
+import "../../../chunk-ZGOMCU4T.js";
+import "../../../chunk-IZEPCXYK.js";
+import "../../../chunk-ZC33GE2U.js";
+import "../../../chunk-J3P6W53K.js";
+import "../../../chunk-QW2GGDEG.js";
+import "../../../chunk-LE2SDA4O.js";
+import "../../../chunk-7QVYU63E.js";
 export {
   upload_files
 };

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

@@ -1 +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":[]}
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

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

@@ -1,6 +1,6 @@
 import {
   handleError
-} from "../../../chunk-P5XJG7OG.js";
+} from "../../../chunk-A7GR4LD2.js";
 import "../../../chunk-7QVYU63E.js";
 export {
   handleError

package/dist/utility/utilis/general/file-operations.d.ts

@@ -1,141 +1,16 @@
-import { PathOptions } from '../../libs/interface.js';
+import { PathOptions } from '../../libs/types.js';
+import { DownloadablePath } from '../../libs/interface.js';
 import 'mongodb';
-import '../../libs/types.js';
 import 'express';
 import '../../libs/env.js';
 
 declare function fileExistsAsync(filePath: string): Promise<boolean>;
-/**
- * Extracts the file extension from a supported file input.
- *
- * Supports Express Multer files, Web API `File` objects, raw `Buffer` values,
- * and file paths or URLs. For URLs and paths, query parameters and hash
- * fragments are ignored when determining the extension.
- *
- * @param input - The file, buffer, path, or URL from which to extract the extension.
- * @returns The file extension without the leading dot, converted to lowercase.
- * Returns an empty string if no extension can be determined.
- *
- * @example
- * const extension = getFileExtension('https://example.com/files/image.PNG');
- * // Returns: "png"
- *
- * @example
- * const extension = getFileExtension(req.file);
- * // Returns: "pdf"
- *
- * @example
- * const extension = getFileExtension('documents/report.pdf?download=true');
- * // Returns: "pdf"
- *
- * @example
- * const extension = getFileExtension(buffer);
- * // Returns: ""
- */
+declare function fileExistsSync(filePath: string): boolean;
 declare function getFileExtension(input: Express.Multer.File | File | Buffer | string): string;
-/**
- * Builds a normalized file path from the provided path components.
- *
- * Combines the path prefix, path segments, path postfix, and file name,
- * while removing empty values and normalizing redundant slashes.
- *
- * If `fileName` is a Web API `File` object, its `name` property is used.
- *
- * @param options - The path components used to construct the final path.
- * @param options.path_prefix - An optional prefix to prepend to the path.
- * @param options.path - An array of path segments.
- * @param options.path_postfix - An optional postfix to append before the file name.
- * @param options.fileName - The file name or a Web API `File` object.
- * @returns A normalized path with components separated by a single slash.
- *
- * @example
- * const filePath = buildPath({
- *     path_prefix: 'uploads',
- *     path: ['documents', 'reports'],
- *     fileName: 'report.pdf',
- * });
- * // Returns: "uploads/documents/reports/report.pdf"
- *
- * @example
- * const filePath = buildPath({
- *     path: ['documents//', '/reports/'],
- *     fileName: 'report.pdf',
- * });
- * // Returns: "documents/reports/report.pdf"
- */
-declare function buildPath({ path_prefix, path, path_postfix, fileName, }: PathOptions): string;
-/**
- * Builds the local file path for a downloaded file.
- *
- * Removes any occurrence of the configured in-app bucket from the provided
- * path to prevent duplicating the bucket name, then constructs the final
- * path using the configured in-app bucket as the path prefix.
- *
- * @param options - The path and file name options used to build the downloaded file path.
- * @param options.path - The path segments leading to the file.
- * @param options.fileName - The name of the file or a Web API `File` object.
- * @returns The complete local path for the downloaded file.
- *
- * @example
- * const filePath = downloadedFilePath({
- *     path: ['documents', 'reports'],
- *     fileName: 'report.pdf',
- * });
- * // Returns a path prefixed with ENV.IN_APP_BUCKET.
- *
- * @example
- * const filePath = downloadedFilePath({
- *     path: [ENV.IN_APP_BUCKET, 'documents'],
- *     fileName: file,
- * });
- * // The duplicate bucket segment is removed before building the path.
- */
-declare function downloadedFilePath({ path, fileName }: PathOptions): string;
-/**
- * Determines the MIME content type of a file from its available metadata
- * or, when given a file path or URL, from its file extension.
- *
- * Supports Express Multer files, Web API `File` objects, raw `Buffer` values,
- * and file paths or URLs.
- *
- * @param file - The file, buffer, path, or URL whose content type should be determined.
- * @returns A promise resolving to the detected MIME content type.
- *
- * @example
- * const contentType = await getFileContentType(req.file);
- * // Returns something like: "image/jpeg"
- *
- * @example
- * const contentType = await getFileContentType('/uploads/document.pdf');
- * // Returns: "application/pdf"
- *
- * @example
- * const contentType = await getFileContentType(buffer);
- * // Returns: "application/octet-stream"
- */
+declare function buildPath(options: PathOptions): string;
+declare function getInAppBucketDownloadPath({ segments, fileName, }?: DownloadablePath): string;
 declare const getFileContentType: (file: Express.Multer.File | File | Buffer | string) => Promise<string>;
-/**
- * Determines whether the provided value is a URL or a local/server based file path.
- *
- * If the value is a valid HTTP/HTTPS URL, the configured URL environment
- * value is returned. Otherwise, the configured local path environment value
- * is returned.
- *
- * @param val - The URL or local file path to evaluate.
- * @returns The configured URL or local path based on the input type.
- *
- * @example
- * const basePath = url_or_path('https://example.com/file.png');
- * // Returns ENV.URL
- *
- * @example
- * const basePath = url_or_path('/uploads/file.png');
- * // Returns ENV.PATH
- */
-declare const url_or_path: (val: string) => string;
-/**
- * Safely normalizes Buffer, Express.Multer.File, Web File, or File Path into Uint8Array
- */
+declare const url_or_path: (val: string) => "url" | "path";
 declare function toUint8Array(file: Express.Multer.File | File | Buffer | string): Promise<Uint8Array>;
 
-export { buildPath, downloadedFilePath, fileExistsAsync, getFileContentType, getFileExtension, toUint8Array, url_or_path };
+export { buildPath, fileExistsAsync, fileExistsSync, getFileContentType, getFileExtension, getInAppBucketDownloadPath, toUint8Array, url_or_path };

package/dist/utility/utilis/general/file-operations.js

@@ -1,20 +1,22 @@
 import {
   buildPath,
-  downloadedFilePath,
   fileExistsAsync,
+  fileExistsSync,
   getFileContentType,
   getFileExtension,
+  getInAppBucketDownloadPath,
   toUint8Array,
   url_or_path
-} from "../../../chunk-W3W3X2OE.js";
-import "../../../chunk-EWQYVPOL.js";
+} from "../../../chunk-QW2GGDEG.js";
+import "../../../chunk-LE2SDA4O.js";
 import "../../../chunk-7QVYU63E.js";
 export {
   buildPath,
-  downloadedFilePath,
   fileExistsAsync,
+  fileExistsSync,
   getFileContentType,
   getFileExtension,
+  getInAppBucketDownloadPath,
   toUint8Array,
   url_or_path
 };

package/dist/utility/utilis/general/sqlDb.js.d.ts

@@ -3,149 +3,8 @@ import 'mongodb';
 import 'express';
 import '../../libs/env.js';
 
-/**
- * Detects the SQL database type from a database connection URL.
- *
- * The function supports MySQL and PostgreSQL connection URL schemes,
- * including common driver-specific variants such as `mysql2`,
- * `mysql+pymysql`, `postgresql+psycopg2`, and `postgresql+asyncpg`.
- *
- * If the connection string does not contain a recognized protocol, the
- * function attempts to identify the database using keywords in the
- * connection string or the default database ports:
- *
- * - MySQL: `3306`
- * - PostgreSQL: `5432`
- *
- * Invalid URLs are also checked as raw connection strings before an error
- * is thrown. This allows common connection strings without a protocol to
- * still be detected.
- *
- * @param url - The SQL database connection URL or connection string.
- * @returns `ENV.MY_SQL` for MySQL connections or `ENV.POSTGRES_SQL` for
- * PostgreSQL connections.
- * @throws {Error} If the URL is invalid or the database type cannot be
- * identified as MySQL or PostgreSQL.
- *
- * @example
- * // Detect PostgreSQL from a standard connection URL.
- * const database = detectSQLDatabase(
- *     'postgresql://user:password@localhost:5432/my_database'
- * );
- *
- * // Returns: ENV.POSTGRES_SQL
- *
- * @example
- * // Detect MySQL from a standard connection URL.
- * const database = detectSQLDatabase(
- *     'mysql://user:password@localhost:3306/my_database'
- * );
- *
- * // Returns: ENV.MY_SQL
- *
- * @example
- * // Driver-specific PostgreSQL URLs are also supported.
- * const database = detectSQLDatabase(
- *     'postgresql+psycopg2://user:password@localhost:5432/my_database'
- * );
- *
- * // Returns: ENV.POSTGRES_SQL
- *
- * @example
- * // A connection string without a recognized protocol can be detected
- * // using the default PostgreSQL port.
- * const database = detectSQLDatabase(
- *     'localhost:5432/my_database'
- * );
- *
- * // Returns: ENV.POSTGRES_SQL
- *
- * @example
- * // Throws when the database type cannot be determined.
- * const database = detectSQLDatabase(
- *     'mongodb://localhost:27017/my_database'
- * );
- *
- * // Error: Unsupported or unrecognized database type.
- */
 declare function detectSQLDatabase(url: string): DatabaseType;
-/**
- * Determines whether a database connection URL represents a MySQL database.
- *
- * This function delegates database detection to `detectSQLDatabase()` and
- * compares the detected database type with the configured MySQL database
- * identifier.
- *
- * Any error encountered while parsing or detecting the database type is
- * handled internally, and the function returns `false` instead of throwing.
- * This makes the function safe to use when validating or conditionally
- * selecting a database implementation.
- *
- * @param url - The SQL database connection URL or connection string.
- * @returns `true` if the URL represents a MySQL database; otherwise `false`.
- *
- * @example
- * // Standard MySQL connection URL.
- * const result = isMySQL(
- *     'mysql://user:password@localhost:3306/my_database'
- * );
- *
- * // Returns: true
- *
- * @example
- * // PostgreSQL URL.
- * const result = isMySQL(
- *     'postgresql://user:password@localhost:5432/my_database'
- * );
- *
- * // Returns: false
- *
- * @example
- * // Invalid or unsupported connection URL.
- * const result = isMySQL('invalid-database-url');
- *
- * // Returns: false instead of throwing an error.
- */
 declare function isMySQL(url: string): boolean;
-/**
- * Determines whether a database connection URL represents a PostgreSQL
- * database.
- *
- * This function delegates database detection to `detectSQLDatabase()` and
- * compares the detected database type with the configured PostgreSQL
- * identifier.
- *
- * Any error encountered while parsing or detecting the database type is
- * handled internally, causing the function to return `false` instead of
- * throwing. This makes the function safe to use when conditionally selecting
- * PostgreSQL-specific database logic.
- *
- * @param url - The SQL database connection URL or connection string.
- * @returns `true` if the URL represents a PostgreSQL database; otherwise
- * `false`.
- *
- * @example
- * // Standard PostgreSQL connection URL.
- * const result = isPostgreSQL(
- *     'postgresql://user:password@localhost:5432/my_database'
- * );
- *
- * // Returns: true
- *
- * @example
- * // MySQL connection URL.
- * const result = isPostgreSQL(
- *     'mysql://user:password@localhost:3306/my_database'
- * );
- *
- * // Returns: false
- *
- * @example
- * // Invalid or unsupported connection URL.
- * const result = isPostgreSQL('invalid-database-url');
- *
- * // Returns: false instead of throwing an error.
- */
 declare function isPostgreSQL(url: string): boolean;
 
 export { detectSQLDatabase, isMySQL, isPostgreSQL };

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

@@ -2,8 +2,8 @@ import {
   detectSQLDatabase,
   isMySQL,
   isPostgreSQL
-} from "../../../chunk-MNSQSU7T.js";
-import "../../../chunk-EWQYVPOL.js";
+} from "../../../chunk-O5ILFRFV.js";
+import "../../../chunk-LE2SDA4O.js";
 import "../../../chunk-7QVYU63E.js";
 export {
   detectSQLDatabase,

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

@@ -4,49 +4,6 @@ import '../../libs/types.js';
 import 'express';
 import '../../libs/env.js';
 
-/**
- * Generates one or more cryptographically secure unique values.
- *
- * Values can be generated using hexadecimal characters or a custom
- * alphanumeric character set. Optional timestamps and prefixes can be
- * included in the generated values.
- *
- * When `count` is provided, multiple unique values are returned as an array.
- * Otherwise, a single string is returned.
- *
- * @param length - The length of the randomly generated portion of each value.
- * @param options - Optional configuration for generating the value(s).
- * @param options.useHex - Whether to generate the random portion using hexadecimal characters.
- * @param options.includeTimestamp - Whether to prepend a hexadecimal timestamp.
- * @param options.prefix - An optional prefix to prepend to the generated value.
- * @param options.count - The number of values to generate. If omitted, one value is returned.
- * @returns A single unique string when `count` is not provided, or an array of unique strings when `count` is specified.
- * @throws {Error} If `length` or `count` is less than or equal to zero.
- *
- * @example
- * const id = generateUniqueValue(16);
- * // Returns: "aZ7_kP2mQ9xL3nBc"
- *
- * @example
- * const id = generateUniqueValue(16, {
- *     useHex: true,
- *     prefix: 'file',
- * });
- * // Returns: "file-7f3a9c12d84e..."
- *
- * @example
- * const id = generateUniqueValue(12, {
- *     includeTimestamp: true,
- * });
- * // Returns: "198a7f3c12a-7Kx9mP..."
- *
- * @example
- * const ids = generateUniqueValue(10, {
- *     count: 5,
- *     prefix: 'file',
- * });
- * // Returns: ["file-...", "file-...", "file-...", "file-...", "file-..."]
- */
 declare function generateUniqueValue(length: number, options?: GenerateIdOptions): string;
 declare function generateUniqueValue(length: number, options: GenerateIdOptions & {
     count: number;

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

@@ -1,6 +1,6 @@
 import {
   generateUniqueValue
-} from "../../../chunk-X3R3RLXY.js";
+} from "../../../chunk-IZEPCXYK.js";
 import "../../../chunk-7QVYU63E.js";
 export {
   generateUniqueValue