arkos 2.0.0-next.13 → 2.0.0-next.16

package/dist/esm/utils/arkos-router/utils/helpers/upload-manager.js

@@ -10,7 +10,6 @@ import AppError from "../../../../modules/error-handler/utils/app-error.js";
 import { extractRequestInfo, generateRelativePath, } from "../../../../modules/file-upload/utils/helpers/file-upload.helpers.js";
 import deepmerge from "../../../helpers/deepmerge.helper.js";
 import { catchAsync } from "../../../../exports/error-handler/index.js";
-import { pascalCase } from "../../../helpers/change-case.helpers.js";
 function determineUploadDir(file) {
     if (file.mimetype.includes?.("image"))
         return "/images";
@@ -41,6 +40,112 @@ const storage = multer.diskStorage({
         cb(null, `${file.originalname.replace(ext, "")}-${uniqueSuffix}${ext}`);
     },
 });
+function isNestedArrayPath(fieldPath) {
+    return fieldPath.includes("[]");
+}
+function buildPathMatcher(pattern) {
+    const escaped = pattern
+        .replace(/\[]/g, "\x00")
+        .replace(/[\[\]]/g, "\\$&")
+        .replace(/\x00/g, "\\[\\d+\\]");
+    return new RegExp(`^${escaped}$`);
+}
+function extractIndex(segment) {
+    return parseInt(segment.replace(/\[|\]/g, ""), 10);
+}
+function extractIndices(key, pattern) {
+    const patternParts = pattern.match(/\[[^\]]*\]/g) || [];
+    const keyParts = key.match(/\[[^\]]*\]/g) || [];
+    const indices = [];
+    for (let i = 0; i < patternParts.length; i++) {
+        if (patternParts[i] === "[]") {
+            indices.push(extractIndex(keyParts[i]));
+        }
+    }
+    return indices;
+}
+function groupFilesByPattern(files, pattern) {
+    const matcher = buildPathMatcher(pattern);
+    const groups = new Map();
+    for (const key of Object.keys(files)) {
+        if (!matcher.test(key))
+            continue;
+        const indices = extractIndices(key, pattern);
+        const groupKey = indices.join(",");
+        if (!groups.has(groupKey))
+            groups.set(groupKey, []);
+        groups.get(groupKey).push(...files[key]);
+    }
+    return groups;
+}
+function validateFileConstraints(file, allowedFileTypes, maxSize) {
+    if (maxSize && file.size > maxSize) {
+        return `File '${file.originalname}' exceeds the maximum allowed size of ${maxSize} bytes`;
+    }
+    if (allowedFileTypes) {
+        const ext = path.extname(file.originalname).toLowerCase();
+        const allowed = Array.isArray(allowedFileTypes)
+            ? allowedFileTypes.includes(ext)
+            : allowedFileTypes.test(ext);
+        if (!allowed) {
+            return `File type '${ext}' is not allowed for '${file.originalname}'`;
+        }
+    }
+    return null;
+}
+function flattenFieldsForMulter(fields) {
+    return fields.map((field) => ({
+        name: field.name,
+        maxCount: "type" in field && field.type === "single" ? 1 : (field.maxCount ?? 5),
+    }));
+}
+function configHasNestedArrayPaths(config) {
+    if (config.type === "single" || config.type === "array") {
+        return isNestedArrayPath(config.field);
+    }
+    if (config.type === "fields") {
+        return config.fields.some((f) => isNestedArrayPath(f.name));
+    }
+    return false;
+}
+function resolveFieldEntry(field, config = {}) {
+    const isLegacy = !("type" in field) || field.type === undefined;
+    if (isLegacy) {
+        return {
+            ...config,
+            name: field.name,
+            type: "array",
+            required: !!config.required,
+            minCount: field.minCount,
+            maxCount: field.maxCount,
+            allowedFileTypes: config.allowedFileTypes,
+            maxSize: config.maxSize,
+            attachToBody: config.attachToBody,
+        };
+    }
+    if (field.type === "single") {
+        return {
+            name: field.name,
+            type: "single",
+            required: field.required !== false,
+            minCount: undefined,
+            maxCount: undefined,
+            allowedFileTypes: field.allowedFileTypes,
+            maxSize: field.maxSize,
+            attachToBody: field.attachToBody,
+        };
+    }
+    return {
+        name: field.name,
+        type: "array",
+        required: field.required !== false,
+        minCount: field.minCount,
+        maxCount: field.maxCount,
+        allowedFileTypes: field.allowedFileTypes,
+        maxSize: field.maxSize,
+        attachToBody: field.attachToBody,
+    };
+}
 class UploadManager {
     constructor() {
         this.fileFilter = (_, file, cb, allowedFileTypes) => {
@@ -64,22 +169,42 @@ class UploadManager {
         });
     }
     getMiddleware(config) {
-        let upload;
-        if (config.type === "single")
-            upload = this.getUpload(config)[config.type](config.field);
-        else if (config.type === "array")
-            upload = this.getUpload(config)[config.type](config.field, config.maxCount || 5);
-        else
-            upload = this.getUpload(config)[config.type](config.fields);
-        return upload;
+        if (configHasNestedArrayPaths(config)) {
+            return multer({ storage }).any();
+        }
+        if (config.type === "single") {
+            return this.getUpload(config).single(config.field);
+        }
+        else if (config.type === "array") {
+            return this.getUpload(config).array(config.field, config.maxCount ?? 5);
+        }
+        else {
+            const multerOptions = "maxSize" in config || "allowedFileTypes" in config
+                ? {
+                    maxSize: config.maxSize,
+                    allowedFileTypes: config.allowedFileTypes,
+                }
+                : {};
+            return this.getUpload(multerOptions).fields(flattenFieldsForMulter(config.fields));
+        }
     }
     handleUpload(config, oldFilePath) {
         return catchAsync((req, res, next) => {
             const middleware = this.getMiddleware(config);
-            req.headers["x-upload-dir"] = config.uploadDir;
+            req.headers["x-upload-dir"] =
+                "uploadDir" in config ? config.uploadDir : undefined;
             middleware(req, res, async (err) => {
                 if (err)
                     return next(err);
+                if (configHasNestedArrayPaths(config) && Array.isArray(req.files)) {
+                    const normalized = {};
+                    for (const file of req.files) {
+                        if (!normalized[file.fieldname])
+                            normalized[file.fieldname] = [];
+                        normalized[file.fieldname].push(file);
+                    }
+                    req.files = normalized;
+                }
                 if (oldFilePath) {
                     const { fileUpload: configs } = getArkosConfig();
                     const filePath = path.resolve(process.cwd(), removeBothSlashes(configs?.baseUploadDir), removeBothSlashes(oldFilePath));
@@ -100,43 +225,98 @@ class UploadManager {
         return catchAsync((req, _, next) => {
             const errors = [];
             const errorCodes = [];
-            if (uploadConfig.required === false)
-                return next();
-            if (uploadConfig.type === "single") {
-                if (!req.file) {
-                    errors.push(`Required upload field '${uploadConfig.field}' is missing`);
-                    errorCodes.push(uploadConfig.field);
+            const addError = (msg, code) => {
+                errors.push(msg);
+                errorCodes.push(code);
+            };
+            const validateField = (field, type, required, minCount, maxCount, allowedFileTypes, maxSize) => {
+                const isNested = isNestedArrayPath(field);
+                if (isNested) {
+                    const filesObj = req.files;
+                    if (!filesObj || Array.isArray(filesObj)) {
+                        if (required)
+                            addError(`Required field '${field}' is missing`, field);
+                        return;
+                    }
+                    const groups = groupFilesByPattern(filesObj, field);
+                    if (groups.size === 0) {
+                        if (required)
+                            addError(`Required field '${field}' is missing`, field);
+                        return;
+                    }
+                    for (const [groupKey, groupFiles] of groups) {
+                        const label = `'${field}' (group ${groupKey})`;
+                        if (type === "single" && groupFiles.length !== 1) {
+                            addError(`Field ${label} must have exactly 1 file`, field);
+                        }
+                        if (type === "array") {
+                            if (minCount && groupFiles.length < minCount) {
+                                addError(`Field ${label} requires at least ${minCount} files, got ${groupFiles.length}`, field);
+                            }
+                            if (maxCount && groupFiles.length > maxCount) {
+                                addError(`Field ${label} allows at most ${maxCount} files, got ${groupFiles.length}`, field);
+                            }
+                        }
+                        for (const file of groupFiles) {
+                            const err = validateFileConstraints(file, allowedFileTypes, maxSize);
+                            if (err)
+                                addError(err, field);
+                        }
+                    }
+                }
+                else {
+                    if (type === "single") {
+                        if (required && !req.file) {
+                            addError(`Required upload field '${field}' is missing`, field);
+                        }
+                    }
+                    else {
+                        const filesObj = req.files;
+                        const files = Array.isArray(req.files)
+                            ? req.files
+                            : filesObj?.[field];
+                        if (!files || files.length === 0) {
+                            if (required)
+                                addError(`Required upload field '${field}' is missing or empty`, field);
+                        }
+                        else if (!Array.isArray(files)) {
+                            if (required)
+                                addError(`Malformed upload field '${field}'`, field);
+                        }
+                        else {
+                            if (minCount && files.length < minCount) {
+                                addError(`Field '${field}' requires at least ${minCount} files, got ${files.length}`, field);
+                            }
+                        }
+                    }
                 }
+            };
+            if (uploadConfig.type === "single") {
+                validateField(uploadConfig.field, "single", uploadConfig.required !== false, undefined, undefined, isNestedArrayPath(uploadConfig.field)
+                    ? uploadConfig.allowedFileTypes
+                    : undefined, isNestedArrayPath(uploadConfig.field)
+                    ? uploadConfig.maxSize
+                    : undefined);
             }
             else if (uploadConfig.type === "array") {
-                if (!req.files || !Array.isArray(req.files) || req.files.length === 0) {
-                    errors.push(`Required upload field '${uploadConfig.field}' is missing or empty`);
-                    errorCodes.push(uploadConfig.field);
-                }
+                validateField(uploadConfig.field, "array", uploadConfig.required !== false, uploadConfig.minCount, uploadConfig.maxCount, isNestedArrayPath(uploadConfig.field)
+                    ? uploadConfig.allowedFileTypes
+                    : undefined, isNestedArrayPath(uploadConfig.field)
+                    ? uploadConfig.maxSize
+                    : undefined);
             }
             else if (uploadConfig.type === "fields") {
-                if (!req.files ||
-                    typeof req.files !== "object" ||
-                    Array.isArray(req.files)) {
-                    errors.push(`Required upload fields are missing. Expected an object with fields: ${uploadConfig.fields.map((f) => f.name).join(", ")}`);
-                    errorCodes.push(...uploadConfig.fields.map((f) => f.name));
-                }
-                else {
-                    for (const field of uploadConfig.fields) {
-                        const filesForField = req.files[field.name];
-                        if (!filesForField ||
-                            !Array.isArray(filesForField) ||
-                            filesForField.length === 0) {
-                            errors.push(`Required upload field '${field.name}' is missing or empty`);
-                            errorCodes.push(field.name);
-                        }
-                    }
+                for (const fieldEntry of uploadConfig.fields) {
+                    const resolved = resolveFieldEntry(fieldEntry, uploadConfig);
+                    validateField(resolved.name, resolved.type, resolved.required, resolved.minCount, resolved.maxCount, isNestedArrayPath(resolved.name)
+                        ? resolved.allowedFileTypes
+                        : undefined, isNestedArrayPath(resolved.name) ? resolved.maxSize : undefined);
                 }
             }
             if (errors.length > 0) {
-                throw new AppError(errors[0], 400, `Missing${pascalCase(errorCodes[0]).replaceAll("_", "")}FileField`, {
-                    errors,
-                });
+                throw new AppError(errors[0], 400, uploadConfig.type !== "single"
+                    ? `MissingUploadFields`
+                    : `MissingUploadField`, { errors });
             }
             next();
         });
@@ -156,7 +336,8 @@ class UploadManager {
                     await deleteFile(req.file);
                     delete req.file;
                 }
-                else if (config.type === "array" && Array.isArray(req.files)) {
+                else if ((config.type === "array" || configHasNestedArrayPaths(config)) &&
+                    Array.isArray(req.files)) {
                     for (const file of req.files) {
                         await deleteFile(file);
                     }
@@ -196,23 +377,21 @@ class UploadManager {
                 const relativePath = generateRelativePath(file.path, req.headers["x-upload-dir"]);
                 return `${baseURL}${baseRoute === "/" ? "" : baseRoute}${relativePath.startsWith("/") ? relativePath : `/${relativePath}`}`;
             };
-            const getAttachValue = (file) => {
+            const getAttachValue = (file, attachToBody) => {
                 const url = buildFileURL(file);
                 file.url = url;
                 file.pathname = normalizePath(file.path);
-                if (config.attachToBody === false)
+                if (attachToBody === false)
                     return undefined;
-                if (config.attachToBody === "pathname" || !config.attachToBody)
-                    return ((baseRoute === "/"
-                        ? ""
-                        : baseRoute.startsWith("/")
-                            ? baseRoute
-                            : `/${baseRoute}`) + normalizePath(file.path));
-                if (config.attachToBody === "url")
+                if (attachToBody === "url")
                     return url;
-                if (config.attachToBody === "file")
+                if (attachToBody === "file")
                     return file;
-                return undefined;
+                return ((baseRoute === "/"
+                    ? ""
+                    : baseRoute.startsWith("/")
+                        ? baseRoute
+                        : `/${baseRoute}`) + normalizePath(file.path));
             };
             const setNestedValue = (obj, path, value) => {
                 const keys = path.match(/[^\[\]]+/g) || [];
@@ -228,41 +407,119 @@ class UploadManager {
                 const lastKey = keys[keys.length - 1];
                 current[lastKey] = value;
             };
-            try {
-                if (config.type === "single" && req.file) {
-                    const value = getAttachValue(req.file);
-                    if (value !== undefined && config.field) {
-                        const bodyUpdate = {};
-                        setNestedValue(bodyUpdate, config.field, value);
-                        req.body = deepmerge(req.body || {}, bodyUpdate);
+            const reconstructNestedArrayPath = (pattern, filesObj, attachToBody, type, sharedBodyUpdate) => {
+                const groups = groupFilesByPattern(filesObj, pattern);
+                if (groups.size === 0)
+                    return;
+                const segments = pattern.match(/[^\[\]]+|\[\]/g) || [];
+                const sortedGroups = [...groups.entries()].sort((a, b) => {
+                    const ai = a[0].split(",").map(Number);
+                    const bi = b[0].split(",").map(Number);
+                    for (let i = 0; i < Math.min(ai.length, bi.length); i++) {
+                        if (ai[i] !== bi[i])
+                            return ai[i] - bi[i];
                     }
-                }
-                else if (config.type === "array" && Array.isArray(req.files)) {
-                    const values = req.files
-                        .map((file) => getAttachValue(file))
+                    return 0;
+                });
+                const bodyUpdate = sharedBodyUpdate ?? {};
+                for (const [groupKey, groupFiles] of sortedGroups) {
+                    const indices = groupKey.split(",").map(Number);
+                    let indexCounter = 0;
+                    const concretePath = segments
+                        .map((seg) => {
+                        if (seg === "[]")
+                            return `[${indices[indexCounter++]}]`;
+                        return seg;
+                    })
+                        .reduce((acc, seg, i) => {
+                        if (i === 0)
+                            return seg;
+                        if (seg.startsWith("["))
+                            return acc + seg;
+                        return acc + `[${seg}]`;
+                    }, "");
+                    const values = groupFiles
+                        .map((f) => getAttachValue(f, attachToBody))
                         .filter((v) => v !== undefined);
-                    if (values.length > 0 && config.field) {
-                        const bodyUpdate = {};
-                        setNestedValue(bodyUpdate, config.field, values);
-                        req.body = deepmerge(req.body || {}, bodyUpdate);
+                    if (values.length === 0)
+                        continue;
+                    const valueToSet = type === "single" ? values[0] : values;
+                    setNestedValue(bodyUpdate, concretePath, valueToSet);
+                }
+                if (!sharedBodyUpdate) {
+                    req.body = deepmerge(req.body || {}, bodyUpdate);
+                }
+            };
+            try {
+                if (config.type === "single") {
+                    if (isNestedArrayPath(config.field)) {
+                        const filesObj = req.files;
+                        if (filesObj && !Array.isArray(filesObj)) {
+                            reconstructNestedArrayPath(config.field, filesObj, config.attachToBody, "single");
+                        }
+                    }
+                    else if (req.file) {
+                        const value = getAttachValue(req.file, config.attachToBody);
+                        if (value !== undefined) {
+                            const bodyUpdate = {};
+                            setNestedValue(bodyUpdate, config.field, value);
+                            req.body = deepmerge(req.body || {}, bodyUpdate);
+                        }
                     }
                 }
-                else if (config.type === "fields" &&
-                    req.files &&
-                    !Array.isArray(req.files)) {
-                    const bodyUpdate = {};
-                    for (const fieldName in req.files) {
-                        const files = req.files[fieldName];
-                        const values = files
-                            .map((file) => getAttachValue(file))
+                else if (config.type === "array") {
+                    if (isNestedArrayPath(config.field)) {
+                        const filesObj = req.files;
+                        if (filesObj && !Array.isArray(filesObj)) {
+                            reconstructNestedArrayPath(config.field, filesObj, config.attachToBody, "array");
+                        }
+                    }
+                    else if (Array.isArray(req.files)) {
+                        const values = req.files
+                            .map((file) => getAttachValue(file, config.attachToBody))
                             .filter((v) => v !== undefined);
                         if (values.length > 0) {
-                            const valueToAttach = values.length === 1 ? values[0] : values;
-                            setNestedValue(bodyUpdate, fieldName, valueToAttach);
+                            const bodyUpdate = {};
+                            setNestedValue(bodyUpdate, config.field, values);
+                            req.body = deepmerge(req.body || {}, bodyUpdate);
+                        }
+                    }
+                }
+                else if (config.type === "fields") {
+                    const filesObj = req.files;
+                    if (!filesObj || Array.isArray(filesObj))
+                        return next();
+                    const bodyUpdate = {};
+                    const configAttachToBody = "attachToBody" in config ? config.attachToBody : undefined;
+                    for (const fieldEntry of config.fields) {
+                        const resolved = resolveFieldEntry(fieldEntry);
+                        if (isNestedArrayPath(resolved.name)) {
+                            reconstructNestedArrayPath(resolved.name, filesObj, resolved.attachToBody ?? configAttachToBody, resolved.type, bodyUpdate);
+                        }
+                        else {
+                            const files = filesObj[resolved.name];
+                            if (!files || files.length === 0)
+                                continue;
+                            const attachTo = resolved.attachToBody ?? configAttachToBody;
+                            const values = files
+                                .map((f) => getAttachValue(f, attachTo))
+                                .filter((v) => v !== undefined);
+                            if (values.length === 0)
+                                continue;
+                            const valueToAttach = resolved.type === "single" ? values[0] : values;
+                            setNestedValue(bodyUpdate, resolved.name, valueToAttach);
                         }
                     }
                     if (Object.keys(bodyUpdate).length > 0) {
-                        req.body = deepmerge(req.body || {}, bodyUpdate);
+                        req.body = deepmerge(req.body || {}, bodyUpdate, {
+                            arrayMerge: (target, source) => {
+                                const result = [...target];
+                                source.forEach((item, i) => {
+                                    result[i] = result[i] ? deepmerge(result[i], item) : item;
+                                });
+                                return result;
+                            },
+                        });
                     }
                 }
             }