arkos 1.3.1-beta → 1.3.2-beta

package/dist/esm/modules/file-upload/file-upload.service.js

@@ -1 +1,314 @@
-"use strict";import y from"multer";import p from"path";import m from"fs";import d from"../error-handler/utils/app-error.js";import{promisify as f}from"util";import{getArkosConfig as U}from"../../server.js";import j from"../../utils/helpers/deepmerge.helper.js";import{processFile as F,processImage as k}from"./utils/helpers/file-upload.helpers.js";import{removeBothSlashes as D}from"../../utils/helpers/text.helpers.js";export class FileUploadService{constructor(e,s=1024*1024*5,t=/.*/,a=30){this.fileFilter=(o,i,l)=>{const n=this.allowedFileTypes.test(p.extname(i.originalname).toLowerCase());this.allowedFileTypes.test(i.mimetype)&&n?l(null,!0):l(new d("Invalid file type",400))},e=e.startsWith("/")?e.substring(1):e,e=e.endsWith("/")?e.slice(0,-1):e,this.uploadDir=p.resolve(process.cwd(),`${e}/`),this.fileSizeLimit=s,this.allowedFileTypes=t,this.maxCount=a,m.existsSync(this.uploadDir)||m.mkdirSync(this.uploadDir,{recursive:!0}),this.storage=y.diskStorage({destination:(o,i,l)=>{l(null,this.uploadDir)},filename:(o,i,l)=>{const n=Date.now()+"-"+Math.round(Math.random()*1e9);l(null,`${n}${p.extname(i.originalname)}`)}})}getUpload(){return y({storage:this.storage,fileFilter:this.fileFilter,limits:{fileSize:this.fileSizeLimit}})}handleSingleUpload(e){return(s,t,a)=>{this.getUpload().single(this.getFieldName())(s,t,async i=>{if(i instanceof y.MulterError)return a(i);if(i)return a(i);if(e){const{fileUpload:l}=U(),n=p.resolve(process.cwd(),D(l?.baseUploadDir),D(e));try{await f(m.stat)(n)&&await f(m.unlink)(n)}catch(r){console.error(r)}}a()})}}handleMultipleUpload(){return(e,s,t)=>{this.getUpload().array(this.getFieldName(),this.maxCount)(e,s,o=>{if(o instanceof y.MulterError)return t(o);if(o)return t(o);t()})}}handleDeleteSingleFile(e){return async(s,t,a)=>{const o=p.join(e);try{await f(m.stat)(o)&&await f(m.unlink)(o)}catch(i){console.error(i)}a()}}async deleteFileByUrl(e){try{const{fileUpload:s}=U(),t=s?.baseRoute||"/api/uploads";let a;e.startsWith("http")?a=new URL(e).pathname:a=e;const o=a.indexOf(t);if(o===-1)throw new d("Invalid file URL: base route not found",400);const i=a.substring(o+t.length),l=i.startsWith("/")?i.substring(1):i,n=["images","videos","documents","files"];let r=null,c=null;for(const x of n){const b=l.indexOf(x+"/");if(b!==-1){r=x,c=l.substring(b+x.length+1);break}}if(!r||!c)throw new d("Unable to determine file type or file name from URL",400);const{documentUploadService:g,fileUploadService:u,imageUploadService:S,videoUploadService:h}=getFileUploadServices();let w;switch(r){case"images":w=p.join(S.uploadDir,c);break;case"videos":w=p.join(h.uploadDir,c);break;case"documents":w=p.join(g.uploadDir,c);break;case"files":w=p.join(u.uploadDir,c);break;default:throw new d(`Unsupported file type: ${r}`,400)}return await f(m.stat)(w),await f(m.unlink)(w),!0}catch(s){throw s instanceof d?s:s.code==="ENOENT"?new d("File not found",404):new d(`Failed to delete file: ${s.message}`,500)}}getFieldName(){let e="files";return(this.uploadDir.endsWith("images")||this.uploadDir.endsWith("images/"))&&(e="images"),(this.uploadDir.endsWith("videos")||this.uploadDir.endsWith("videos/"))&&(e="videos"),(this.uploadDir.endsWith("documents")||this.uploadDir.endsWith("documents/"))&&(e="documents"),(this.uploadDir.endsWith("files")||this.uploadDir.endsWith("files/"))&&(e="files"),e}async upload(e,s,t={}){const{fileUpload:a}=U();return a?.baseRoute,new Promise((o,i)=>{((Array.isArray(e.query.multiple)?e.query.multiple[0]=="true":e.query.multiple=="true")?this.getUpload().array(this.getFieldName(),this.maxCount):this.getUpload().single(this.getFieldName()))(e,s,async r=>{if(r)return i(r);try{`${e.get("host")?.includes?.("localhost")?"http":"https"}${e.get("host")}`;const g=this.uploadDir.split("/");this.uploadDir.endsWith("/")?g[g.length-2]:g[g.length-1];let u;if(e.files&&Array.isArray(e.files)&&e.files.length>0)this.uploadDir?.includes?.("/images")?u=await Promise.all(e.files.map(h=>k(e,h.path,t))):u=await Promise.all(e.files.map(h=>F(e,h.path))),u=u.filter(h=>h!==null);else if(e.file)this.uploadDir?.includes?.("/images")?u=await k(e,e.file.path,t):u=await F(e,e.file.path);else return i(new d("No file uploaded",400));o(u)}catch(c){i(c)}})})}async deleteFileByName(e,s){try{if(!s)throw new d("File type parameter is required",400);const t=["images","videos","documents","files"];if(!t.includes(s))throw new d(`Invalid file type: ${s}. Must be one of: ${t.join(", ")}`,400);const{documentUploadService:a,fileUploadService:o,imageUploadService:i,videoUploadService:l}=getFileUploadServices();let n;switch(s){case"images":n=i;break;case"videos":n=l;break;case"documents":n=a;break;case"files":n=o;break;default:throw new d(`Unsupported file type: ${s}`,400)}const r=p.join(n.uploadDir,e);return await f(m.stat)(r),await f(m.unlink)(r),!0}catch(t){throw t instanceof d?t:t.code==="ENOENT"?new d("File not found",404):new d(`Failed to delete file: ${t.message}`,500)}}}export const getFileUploadServices=()=>{const{fileUpload:v}=U(),e=v?.baseUploadDir||"/uploads",s={images:{maxCount:30,maxSize:1024*1024*15,supportedFilesRegex:/jpeg|jpg|png|gif|webp|svg|bmp|tiff|heif|heic|ico|jfif|raw|cr2|nef|orf|sr2|arw|dng|pef|raf|rw2|psd|ai|eps|xcf|jxr|wdp|hdp|jp2|j2k|jpf|jpx|jpm|mj2|avif/},videos:{maxCount:10,maxSize:1024*1024*5096,supportedFilesRegex:/mp4|avi|mov|mkv|flv|wmv|webm|mpg|mpeg|3gp|m4v|ts|rm|rmvb|vob|ogv|dv|qt|asf|m2ts|mts|divx|f4v|swf|mxf|roq|nsv|mvb|svi|mpe|m2v|mp2|mpv|h264|h265|hevc/},documents:{maxCount:30,maxSize:1024*1024*50,supportedFilesRegex:/pdf|doc|docx|xls|xlsx|ppt|pptx|odt|ods|odg|odp|txt|rtf|csv|epub|md|tex|pages|numbers|key|xml|json|yaml|yml|ini|cfg|conf|log|html|htm|xhtml|djvu|mobi|azw|azw3|fb2|lit|ps|wpd|wps|dot|dotx|xlt|xltx|pot|potx|oft|one|onetoc2|opf|oxps|hwp/},files:{maxCount:10,maxSize:1024*1024*5096,supportedFilesRegex:/.*/}},t=v?.restrictions?j(s,v.restrictions):s,a=new FileUploadService(`${e}/images`,t.images.maxSize,t.images.supportedFilesRegex,t.images.maxCount),o=new FileUploadService(`${e}/videos`,t.videos.maxSize,t.videos.supportedFilesRegex,t.videos.maxCount),i=new FileUploadService(`${e}/documents`,t.documents.maxSize,t.documents.supportedFilesRegex,t.documents.maxCount),l=new FileUploadService(`${e}/files`,t.files.maxSize,t.files.supportedFilesRegex,t.files.maxCount);return{imageUploadService:a,videoUploadService:o,documentUploadService:i,fileUploadService:l}};
+import multer from "multer";
+import path from "path";
+import fs from "fs";
+import AppError from "../error-handler/utils/app-error.js";
+import { promisify } from "util";
+import { getArkosConfig } from "../../server.js";
+import deepmerge from "../../utils/helpers/deepmerge.helper.js";
+import { processFile, processImage } from "./utils/helpers/file-upload.helpers.js";
+import { removeBothSlashes } from "../../utils/helpers/text.helpers.js";
+export class FileUploadService {
+    constructor(uploadDir, fileSizeLimit = 1024 * 1024 * 5, allowedFileTypes = /.*/, maxCount = 30) {
+        this.fileFilter = (_, file, cb) => {
+            const extName = this.allowedFileTypes.test(path.extname(file.originalname).toLowerCase());
+            const mimeType = this.allowedFileTypes.test(file.mimetype);
+            if (mimeType && extName) {
+                cb(null, true);
+            }
+            else {
+                cb(new AppError("Invalid file type", 400));
+            }
+        };
+        uploadDir = uploadDir.startsWith("/") ? uploadDir.substring(1) : uploadDir;
+        uploadDir = uploadDir.endsWith("/") ? uploadDir.slice(0, -1) : uploadDir;
+        this.uploadDir = path.resolve(process.cwd(), `${uploadDir}/`);
+        this.fileSizeLimit = fileSizeLimit;
+        this.allowedFileTypes = allowedFileTypes;
+        this.maxCount = maxCount;
+        if (!fs.existsSync(this.uploadDir)) {
+            fs.mkdirSync(this.uploadDir, { recursive: true });
+        }
+        this.storage = multer.diskStorage({
+            destination: (_, _1, cb) => {
+                cb(null, this.uploadDir);
+            },
+            filename: (_, file, cb) => {
+                const uniqueSuffix = Date.now() + "-" + Math.round(Math.random() * 1e9);
+                cb(null, `${uniqueSuffix}${path.extname(file.originalname)}`);
+            },
+        });
+    }
+    getUpload() {
+        return multer({
+            storage: this.storage,
+            fileFilter: this.fileFilter,
+            limits: { fileSize: this.fileSizeLimit },
+        });
+    }
+    handleSingleUpload(oldFilePath) {
+        return (req, res, next) => {
+            const upload = this.getUpload().single(this.getFieldName());
+            upload(req, res, async (err) => {
+                if (err instanceof multer.MulterError) {
+                    return next(err);
+                }
+                else if (err) {
+                    return next(err);
+                }
+                if (oldFilePath) {
+                    const { fileUpload: configs } = getArkosConfig();
+                    const filePath = path.resolve(process.cwd(), removeBothSlashes(configs?.baseUploadDir), removeBothSlashes(oldFilePath));
+                    try {
+                        const stats = await promisify(fs.stat)(filePath);
+                        if (stats)
+                            await promisify(fs.unlink)(filePath);
+                    }
+                    catch (err) {
+                        console.error(err);
+                    }
+                }
+                next();
+            });
+        };
+    }
+    handleMultipleUpload() {
+        return (req, res, next) => {
+            const upload = this.getUpload().array(this.getFieldName(), this.maxCount);
+            upload(req, res, (err) => {
+                if (err instanceof multer.MulterError)
+                    return next(err);
+                else if (err)
+                    return next(err);
+                next();
+            });
+        };
+    }
+    handleDeleteSingleFile(oldFilePath) {
+        return async (_, _1, next) => {
+            const filePath = path.join(oldFilePath);
+            try {
+                const stats = await promisify(fs.stat)(filePath);
+                if (stats) {
+                    await promisify(fs.unlink)(filePath);
+                }
+            }
+            catch (err) {
+                console.error(err);
+            }
+            next();
+        };
+    }
+    async deleteFileByUrl(fileUrl) {
+        try {
+            const { fileUpload } = getArkosConfig();
+            const baseRoute = fileUpload?.baseRoute || "/api/uploads";
+            let urlPath;
+            if (fileUrl.startsWith("http")) {
+                const url = new URL(fileUrl);
+                urlPath = url.pathname;
+            }
+            else {
+                urlPath = fileUrl;
+            }
+            const baseRouteIndex = urlPath.indexOf(baseRoute);
+            if (baseRouteIndex === -1) {
+                throw new AppError("Invalid file URL: base route not found", 400);
+            }
+            const pathAfterBaseRoute = urlPath.substring(baseRouteIndex + baseRoute.length);
+            const cleanPath = pathAfterBaseRoute.startsWith("/")
+                ? pathAfterBaseRoute.substring(1)
+                : pathAfterBaseRoute;
+            const fileTypes = ["images", "videos", "documents", "files"];
+            let fileType = null;
+            let fileName = null;
+            for (const type of fileTypes) {
+                const typeIndex = cleanPath.indexOf(type + "/");
+                if (typeIndex !== -1) {
+                    fileType = type;
+                    fileName = cleanPath.substring(typeIndex + type.length + 1);
+                    break;
+                }
+            }
+            if (!fileType || !fileName) {
+                throw new AppError("Unable to determine file type or file name from URL", 400);
+            }
+            const { documentUploadService, fileUploadService, imageUploadService, videoUploadService, } = getFileUploadServices();
+            let filePath;
+            switch (fileType) {
+                case "images":
+                    filePath = path.join(imageUploadService.uploadDir, fileName);
+                    break;
+                case "videos":
+                    filePath = path.join(videoUploadService.uploadDir, fileName);
+                    break;
+                case "documents":
+                    filePath = path.join(documentUploadService.uploadDir, fileName);
+                    break;
+                case "files":
+                    filePath = path.join(fileUploadService.uploadDir, fileName);
+                    break;
+                default:
+                    throw new AppError(`Unsupported file type: ${fileType}`, 400);
+            }
+            await promisify(fs.stat)(filePath);
+            await promisify(fs.unlink)(filePath);
+            return true;
+        }
+        catch (error) {
+            if (error instanceof AppError) {
+                throw error;
+            }
+            if (error.code === "ENOENT") {
+                throw new AppError("File not found", 404);
+            }
+            throw new AppError(`Failed to delete file: ${error.message}`, 500);
+        }
+    }
+    getFieldName() {
+        let fieldName = "files";
+        if (this.uploadDir.endsWith("images") || this.uploadDir.endsWith("images/"))
+            fieldName = "images";
+        if (this.uploadDir.endsWith("videos") || this.uploadDir.endsWith("videos/"))
+            fieldName = "videos";
+        if (this.uploadDir.endsWith("documents") ||
+            this.uploadDir.endsWith("documents/"))
+            fieldName = "documents";
+        if (this.uploadDir.endsWith("files") || this.uploadDir.endsWith("files/"))
+            fieldName = "files";
+        return fieldName;
+    }
+    async upload(req, res, options = {}) {
+        const { fileUpload } = getArkosConfig();
+        fileUpload?.baseRoute || "/api/uploads";
+        return new Promise((resolve, reject) => {
+            const isMultiple = Array.isArray(req.query.multiple)
+                ? req.query.multiple[0] == "true"
+                : req.query.multiple == "true";
+            const uploadHandler = isMultiple
+                ? this.getUpload().array(this.getFieldName(), this.maxCount)
+                : this.getUpload().single(this.getFieldName());
+            uploadHandler(req, res, async (err) => {
+                if (err)
+                    return reject(err);
+                try {
+                    const protocol = req.get("host")?.includes?.("localhost")
+                        ? "http"
+                        : "https";
+                    `${protocol}://${req.get("host")}`;
+                    const dirParts = this.uploadDir.split("/");
+                    (this.uploadDir.endsWith("/")
+                        ? dirParts[dirParts.length - 2]
+                        : dirParts[dirParts.length - 1]) || "files";
+                    let data;
+                    if (req.files && Array.isArray(req.files) && req.files.length > 0) {
+                        const isImageUpload = this.uploadDir?.includes?.("/images");
+                        if (isImageUpload) {
+                            data = await Promise.all(req.files.map((file) => processImage(req, file.path, options)));
+                        }
+                        else {
+                            data = await Promise.all(req.files.map((file) => processFile(req, file.path)));
+                        }
+                        data = data.filter((url) => url !== null);
+                    }
+                    else if (req.file) {
+                        const isImageUpload = this.uploadDir?.includes?.("/images");
+                        if (isImageUpload) {
+                            data = await processImage(req, req.file.path, options);
+                        }
+                        else {
+                            data = await processFile(req, req.file.path);
+                        }
+                    }
+                    else {
+                        return reject(new AppError("No file uploaded", 400));
+                    }
+                    resolve(data);
+                }
+                catch (error) {
+                    reject(error);
+                }
+            });
+        });
+    }
+    async deleteFileByName(fileName, fileType) {
+        try {
+            if (!fileType)
+                throw new AppError("File type parameter is required", 400);
+            const validFileTypes = ["images", "videos", "documents", "files"];
+            if (!validFileTypes.includes(fileType)) {
+                throw new AppError(`Invalid file type: ${fileType}. Must be one of: ${validFileTypes.join(", ")}`, 400);
+            }
+            const { documentUploadService, fileUploadService, imageUploadService, videoUploadService, } = getFileUploadServices();
+            let targetService;
+            switch (fileType) {
+                case "images":
+                    targetService = imageUploadService;
+                    break;
+                case "videos":
+                    targetService = videoUploadService;
+                    break;
+                case "documents":
+                    targetService = documentUploadService;
+                    break;
+                case "files":
+                    targetService = fileUploadService;
+                    break;
+                default:
+                    throw new AppError(`Unsupported file type: ${fileType}`, 400);
+            }
+            const filePath = path.join(targetService.uploadDir, fileName);
+            await promisify(fs.stat)(filePath);
+            await promisify(fs.unlink)(filePath);
+            return true;
+        }
+        catch (error) {
+            if (error instanceof AppError) {
+                throw error;
+            }
+            if (error.code === "ENOENT") {
+                throw new AppError("File not found", 404);
+            }
+            throw new AppError(`Failed to delete file: ${error.message}`, 500);
+        }
+    }
+}
+export const getFileUploadServices = () => {
+    const { fileUpload } = getArkosConfig();
+    const baseUploadDir = fileUpload?.baseUploadDir || "/uploads";
+    const defaultRestrictions = {
+        images: {
+            maxCount: 30,
+            maxSize: 1024 * 1024 * 15,
+            supportedFilesRegex: /jpeg|jpg|png|gif|webp|svg|bmp|tiff|heif|heic|ico|jfif|raw|cr2|nef|orf|sr2|arw|dng|pef|raf|rw2|psd|ai|eps|xcf|jxr|wdp|hdp|jp2|j2k|jpf|jpx|jpm|mj2|avif/,
+        },
+        videos: {
+            maxCount: 10,
+            maxSize: 1024 * 1024 * 5096,
+            supportedFilesRegex: /mp4|avi|mov|mkv|flv|wmv|webm|mpg|mpeg|3gp|m4v|ts|rm|rmvb|vob|ogv|dv|qt|asf|m2ts|mts|divx|f4v|swf|mxf|roq|nsv|mvb|svi|mpe|m2v|mp2|mpv|h264|h265|hevc/,
+        },
+        documents: {
+            maxCount: 30,
+            maxSize: 1024 * 1024 * 50,
+            supportedFilesRegex: /pdf|doc|docx|xls|xlsx|ppt|pptx|odt|ods|odg|odp|txt|rtf|csv|epub|md|tex|pages|numbers|key|xml|json|yaml|yml|ini|cfg|conf|log|html|htm|xhtml|djvu|mobi|azw|azw3|fb2|lit|ps|wpd|wps|dot|dotx|xlt|xltx|pot|potx|oft|one|onetoc2|opf|oxps|hwp/,
+        },
+        files: {
+            maxCount: 10,
+            maxSize: 1024 * 1024 * 5096,
+            supportedFilesRegex: /.*/,
+        },
+    };
+    const restrictions = fileUpload?.restrictions
+        ? deepmerge(defaultRestrictions, fileUpload.restrictions)
+        : defaultRestrictions;
+    const imageUploadService = new FileUploadService(`${baseUploadDir}/images`, restrictions.images.maxSize, restrictions.images.supportedFilesRegex, restrictions.images.maxCount);
+    const videoUploadService = new FileUploadService(`${baseUploadDir}/videos`, restrictions.videos.maxSize, restrictions.videos.supportedFilesRegex, restrictions.videos.maxCount);
+    const documentUploadService = new FileUploadService(`${baseUploadDir}/documents`, restrictions.documents.maxSize, restrictions.documents.supportedFilesRegex, restrictions.documents.maxCount);
+    const fileUploadService = new FileUploadService(`${baseUploadDir}/files`, restrictions.files.maxSize, restrictions.files.supportedFilesRegex, restrictions.files.maxCount);
+    return {
+        imageUploadService,
+        videoUploadService,
+        documentUploadService,
+        fileUploadService,
+    };
+};
+//# sourceMappingURL=file-upload.service.js.map

package/dist/esm/modules/file-upload/utils/helpers/file-upload.helpers.js

@@ -1 +1,87 @@
-"use strict";import m from"fs";import n from"path";import y from"sharp";import{promisify as u}from"util";import{getArkosConfig as h}from"../../../../server.js";import U from"mimetype";import{fullCleanCwd as x}from"../../../../utils/helpers/fs.helpers.js";export function adjustRequestUrl(t,a,o){const{fileUpload:e}=h();t.url=t.url.replace(e?.baseRoute+"/"||"/api/uploads/","/"),t.url=t.url.replace(e?.baseRoute||"/api/uploads/","/"),o()}export function extractRequestInfo(t){const{fileUpload:a}=h(),e=`${t.headers["x-forwarded-proto"]==="https"?"https":"http"}://${t.get?.("host")}`,i=a?.baseRoute||"/api/uploads";return{baseURL:e,baseRoute:i}}const d=(t,a)=>{const{fileUpload:o}=h(),e=o?.baseUploadDir||"/uploads";return e.startsWith("..")?n.join(a,n.basename(t)):x(t.replace(`${e}/`,"").replace(`/${e}/`,"").replace(`/${e}`,"").replace(`${e}`,""))};export const processFile=async(t,a)=>{const{baseURL:o,baseRoute:e}=extractRequestInfo(t),i=d(a,t.params.fileType);return`${o}${e==="/"?"":e}/${i}`},processImage=async(t,a,o)=>{const{baseURL:e,baseRoute:i}=extractRequestInfo(t),p=n.extname(a).toLowerCase(),w=p.replace(".",""),l=o.format||w;if(!U.lookup(p)?.includes?.("image")){const r=d(a,t.params.fileType);return`${e}${i}/${r}`}const g=`${n.basename(a,p)}_${Date.now()}${p}`,c=n.join(n.dirname(a),g);try{let r=y(a);const s=await r.metadata();if(o.resizeTo&&s.width&&s.height){const f=o.resizeTo/Math.min(s.width,s.height),b=Math.round(s.width*f),R=Math.round(s.height*f);r=r.resize(b,R)}else(o.width||o.height)&&(r=r.resize(o.width||null,o.height||null,{fit:"inside"}));l==="webp"?r=r.toFormat("webp"):(l==="jpeg"||l==="jpg")&&(r=r.toFormat("jpeg")),await r.toFile(c),await u(m.rename)(c,a);const $=d(a,t?.params.fileType);return`${e}${i}/${$}`}catch(r){try{await u(m.stat)(c),await u(m.unlink)(c)}catch{}throw r}};
+import fs from "fs";
+import path from "path";
+import sharp from "sharp";
+import { promisify } from "util";
+import { getArkosConfig } from "../../../../server.js";
+import mimetype from "mimetype";
+import { fullCleanCwd } from "../../../../utils/helpers/fs.helpers.js";
+export function adjustRequestUrl(req, _, next) {
+    const { fileUpload } = getArkosConfig();
+    req.url = req.url.replace(fileUpload?.baseRoute + "/" || "/api/uploads/", "/");
+    req.url = req.url.replace(fileUpload?.baseRoute || "/api/uploads/", "/");
+    next();
+}
+export function extractRequestInfo(req) {
+    const { fileUpload } = getArkosConfig();
+    const protocol = req.headers["x-forwarded-proto"] === "https" ? "https" : "http";
+    const baseURL = `${protocol}://${req.get?.("host")}`;
+    const baseRoute = fileUpload?.baseRoute || "/api/uploads";
+    return { baseURL, baseRoute };
+}
+const generateRelativePath = (filePath, fileType) => {
+    const { fileUpload } = getArkosConfig();
+    const baseUploadDir = fileUpload?.baseUploadDir || "/uploads";
+    if (baseUploadDir.startsWith("..")) {
+        return path.join(fileType, path.basename(filePath));
+    }
+    else {
+        return fullCleanCwd(filePath
+            .replace(`${baseUploadDir}/`, "")
+            .replace(`/${baseUploadDir}/`, "")
+            .replace(`/${baseUploadDir}`, "")
+            .replace(`${baseUploadDir}`, ""));
+    }
+};
+export const processFile = async (req, filePath) => {
+    const { baseURL, baseRoute } = extractRequestInfo(req);
+    const relativePath = generateRelativePath(filePath, req.params.fileType);
+    return `${baseURL}${baseRoute === "/" ? "" : baseRoute}/${relativePath}`;
+};
+export const processImage = async (req, filePath, options) => {
+    const { baseURL, baseRoute } = extractRequestInfo(req);
+    const ext = path.extname(filePath).toLowerCase();
+    const originalFormat = ext.replace(".", "");
+    const outputFormat = options.format || originalFormat;
+    if (!mimetype.lookup(ext)?.includes?.("image")) {
+        const relativePath = generateRelativePath(filePath, req.params.fileType);
+        return `${baseURL}${baseRoute}/${relativePath}`;
+    }
+    const tempName = `${path.basename(filePath, ext)}_${Date.now()}${ext}`;
+    const tempPath = path.join(path.dirname(filePath), tempName);
+    try {
+        let transformer = sharp(filePath);
+        const metadata = await transformer.metadata();
+        if (options.resizeTo && metadata.width && metadata.height) {
+            const targetSize = options.resizeTo;
+            const scaleFactor = targetSize / Math.min(metadata.width, metadata.height);
+            const newWidth = Math.round(metadata.width * scaleFactor);
+            const newHeight = Math.round(metadata.height * scaleFactor);
+            transformer = transformer.resize(newWidth, newHeight);
+        }
+        else if (options.width || options.height) {
+            transformer = transformer.resize(options.width || null, options.height || null, {
+                fit: "inside",
+            });
+        }
+        if (outputFormat === "webp") {
+            transformer = transformer.toFormat("webp");
+        }
+        else if (outputFormat === "jpeg" || outputFormat === "jpg") {
+            transformer = transformer.toFormat("jpeg");
+        }
+        await transformer.toFile(tempPath);
+        await promisify(fs.rename)(tempPath, filePath);
+        const relativePath = generateRelativePath(filePath, req?.params.fileType);
+        return `${baseURL}${baseRoute}/${relativePath}`;
+    }
+    catch (error) {
+        try {
+            await promisify(fs.stat)(tempPath);
+            await promisify(fs.unlink)(tempPath);
+        }
+        catch (err) {
+        }
+        throw error;
+    }
+};
+//# sourceMappingURL=file-upload.helpers.js.map

package/dist/esm/modules/swagger/swagger.router.js

@@ -1 +1,32 @@
-"use strict";import{Router as g}from"express";import c from"swagger-jsdoc";import p from"../../utils/helpers/deepmerge.helper.js";import{generatePathsForModels as f,getOpenAPIJsonSchemasByConfigMode as w}from"./utils/helpers/swagger.router.helpers.js";import d from"./utils/helpers/missing-json-schemas-generator.js";import u from"./utils/helpers/get-swagger-default-configs.js";import{importEsmPreventingTsTransformation as l}from"../../utils/helpers/global.helpers.js";import S from"./utils/helpers/json-schema-generators/generate-system-json-schemas.js";const n=g();export async function getSwaggerRouter(e){let t=await w(e);const r=await f(e);t={...t,...await d.generateMissingJsonSchemas(r,t,e),...S(e)};const o=p(await u(r,t)||{},e.swagger||{}),{definition:a,...s}=o?.options,i=c({definition:a,...s}),m=await l("@scalar/express-api-reference");return n.use(o.endpoint,m.apiReference({content:i,...o?.scalarApiReferenceConfiguration})),n}
+import { Router } from "express";
+import swaggerJsdoc from "swagger-jsdoc";
+import deepmerge from "../../utils/helpers/deepmerge.helper.js";
+import { generatePathsForModels, getOpenAPIJsonSchemasByConfigMode, } from "./utils/helpers/swagger.router.helpers.js";
+import missingJsonSchemaGenerator from "./utils/helpers/missing-json-schemas-generator.js";
+import getSwaggerDefaultConfig from "./utils/helpers/get-swagger-default-configs.js";
+import { importEsmPreventingTsTransformation } from "../../utils/helpers/global.helpers.js";
+import generateSystemJsonSchemas from "./utils/helpers/json-schema-generators/generate-system-json-schemas.js";
+const swaggerRouter = Router();
+export async function getSwaggerRouter(arkosConfig) {
+    let defaultJsonSchemas = await getOpenAPIJsonSchemasByConfigMode(arkosConfig);
+    const defaultModelsPaths = await generatePathsForModels(arkosConfig);
+    defaultJsonSchemas = {
+        ...defaultJsonSchemas,
+        ...(await missingJsonSchemaGenerator.generateMissingJsonSchemas(defaultModelsPaths, defaultJsonSchemas, arkosConfig)),
+        ...generateSystemJsonSchemas(arkosConfig),
+    };
+    const swaggerConfigs = deepmerge((await getSwaggerDefaultConfig(defaultModelsPaths, defaultJsonSchemas)) ||
+        {}, arkosConfig.swagger || {});
+    const { definition, ...options } = swaggerConfigs?.options;
+    const swaggerSpecification = swaggerJsdoc({
+        definition: definition,
+        ...options,
+    });
+    const scalar = await importEsmPreventingTsTransformation("@scalar/express-api-reference");
+    swaggerRouter.use(swaggerConfigs.endpoint, scalar.apiReference({
+        content: swaggerSpecification,
+        ...swaggerConfigs?.scalarApiReferenceConfiguration,
+    }));
+    return swaggerRouter;
+}
+//# sourceMappingURL=swagger.router.js.map