adminizer 4.6.0 → 4.7.0-build.221

package/controllers/edit.js

@@ -1,8 +1,7 @@
 import { ControllerHelper } from "../helpers/controllerHelper.js";
 import { RequestProcessor } from "../lib/requestProcessor.js";
 import { FieldsHelper } from "../helpers/fieldsHelper.js";
-import { redirectToLogin } from '../helpers/inertiaAutHelper.js';
-import { detachMediaManagerField, getRelationsMediaManager, saveRelationsMediaManager } from "../lib/media-manager/helpers/MediaManagerHelper.js";
+import { detachMediaManagerField, getRelationsMediaManager, isMediaManagerFieldConfig, saveRelationsMediaManager, updateCurrentHistoryMediaManagerData } from "../lib/media-manager/helpers/MediaManagerHelper.js";
 import { DataAccessor } from "../lib/DataAccessor.js";
 import { Adminizer } from "../lib/Adminizer.js";
 import inertiaAddHelper from "../helpers/inertiaAddHelper.js";
@@ -11,27 +10,19 @@ export default async function edit(req, res) {
     if (!req.params.id) {
         return res.status(404).send({ error: 'Not Found' });
     }
-    let entity = ControllerHelper.findEntityObject(req);
-    if (!entity.model) {
+    let modelResource = ControllerHelper.findModelResource(req);
+    if (!modelResource.model) {
         return res.status(404).send({ error: 'Not Found' });
     }
-    if (!entity.config.edit) {
-        return res.redirect(`${req.adminizer.config.routePrefix}/${entity.uri}`);
-    }
-    if (req.adminizer.config.auth.enable) {
-        if (!req.user) {
-            return redirectToLogin(req, res);
-        }
-        else if (!req.adminizer.accessRightsHelper.hasPermission(`update-${entity.name}-model`, req.user)) {
-            return res.sendStatus(403);
-        }
+    if (!modelResource.config.edit) {
+        return res.redirect(`${req.adminizer.config.routePrefix}/${modelResource.uri}`);
     }
     let record;
     let dataAccessor;
     const id = req.params.id;
     try {
-        dataAccessor = new DataAccessor(req.adminizer, req.user, entity, "edit");
-        record = await entity.model.findOne({ id: id }, dataAccessor);
+        dataAccessor = new DataAccessor(req.adminizer, req.user, modelResource, "edit");
+        record = await modelResource.model.findOne({ where: { id: id } }, dataAccessor);
         if (!record)
             return res.status(404).send("Adminpanel > Record not found");
     }
@@ -45,11 +36,11 @@ export default async function edit(req, res) {
     fields = await FieldsHelper.loadAssociations(req, fields, "edit");
     // Save
     if (req.method.toUpperCase() === 'POST') {
-        const backUrl = req.body.redirectUrl;
+        const identifierField = modelResource.config.identifierField || req.adminizer.config.identifierField;
         delete req.body.redirectUrl;
         let reqData = RequestProcessor.processRequest(req, fields);
         let params = {};
-        params[entity.config.identifierField || req.adminizer.config.identifierField] = req.params.id;
+        params[modelResource.config.identifierField || req.adminizer.config.identifierField] = req.params.id;
         /**
          * Here means reqData adapt for model data, but rawReqData is processed for widget processing
          */
@@ -65,8 +56,7 @@ export default async function edit(req, res) {
                 reqData[prop] = null;
             }
             let fieldConfigConfig = fields[prop].config;
-            // delete property from association-many and association if empty
-            // TODO check if adding and deleting associations works for other orm (this code was written for waterline)
+            // Normalize empty association payloads before passing them to the adapter
             if (fields[prop] && fields[prop].model && (fields[prop].model.type === 'association-many' || fields[prop].model.type === 'association')) {
                 if (!reqData[prop] || !reqData[prop].length) {
                     reqData[prop] = fields[prop].model.type === 'association' ? null : [];
@@ -77,7 +67,7 @@ export default async function edit(req, res) {
                     }
                 }
             }
-            if (fieldConfigConfig.type === 'mediamanager') {
+            if (isMediaManagerFieldConfig(fieldConfigConfig)) {
                 detachMediaManagerField(reqData, rawReqData, prop);
                 continue;
             }
@@ -102,14 +92,15 @@ export default async function edit(req, res) {
                 reqData[prop] = reqData[prop].join("");
             }
         }
-        // callback before save entity
-        let entityEdit = entity.config.edit;
-        if (typeof entityEdit.entityModifier === "function") {
-            reqData = entityEdit.entityModifier(reqData);
+        // callback before save modelResource
+        let editConfig = modelResource.config.edit;
+        if (typeof editConfig.entityModifier === "function") {
+            reqData = editConfig.entityModifier(reqData);
         }
         try {
-            let newRecord = await entity.model.update(params, reqData, dataAccessor);
-            await saveRelationsMediaManager(req.adminizer, fields, rawReqData, entity.model.modelname, newRecord[0].id);
+            let newRecord = await modelResource.model.update(params, reqData, dataAccessor);
+            await saveRelationsMediaManager(req.adminizer, fields, rawReqData, modelResource.model.modelname, newRecord[0].id);
+            await updateCurrentHistoryMediaManagerData(req.adminizer, fields, rawReqData, modelResource.name, newRecord[0].id);
             Adminizer.log.debug(`Record was updated: `, newRecord);
             if (req.body.jsonPopupCatalog) {
                 return res.json({ record: newRecord });
@@ -120,19 +111,15 @@ export default async function edit(req, res) {
                     for (const section of req.adminizer.config.navigation.sections) {
                         let navigation = req.adminizer.catalogHandler.getCatalog('navigation');
                         navigation.setId(section);
-                        let navItem = navigation.itemTypes.find(item => item.type === entity.name.toLowerCase());
+                        let navItem = navigation.itemTypes.find(item => item.type === modelResource.name.toLowerCase());
                         if (navItem) {
                             await navItem.updateModelItems(newRecord[0].id, { record: newRecord[0] }, section);
                         }
                     }
                 }
                 req.flash.setFlashMessage('success', req.i18n.__('Record was updated'));
-                if (backUrl) {
-                    return req.Inertia.redirect(backUrl);
-                }
-                else {
-                    return req.Inertia.redirect(`${req.adminizer.config.routePrefix}/model/${entity.name}`);
-                }
+                const redirectId = newRecord[0]?.[identifierField] ?? req.params.id;
+                return req.Inertia.redirect(`${req.adminizer.config.routePrefix}/model/${modelResource.name}/edit/${redirectId}`);
             }
         }
         catch (e) {
@@ -143,16 +130,16 @@ export default async function edit(req, res) {
     } // END POST
     for (const field of Object.keys(fields)) {
         const fieldConfigConfig = fields[field].config;
-        if (fieldConfigConfig.type === 'mediamanager') {
+        if (isMediaManagerFieldConfig(fieldConfigConfig)) {
             record[field] = await getRelationsMediaManager(req.adminizer, {
                 mediaManagerId: fieldConfigConfig.options?.id ?? "default",
-                model: entity.model.modelname,
+                model: modelResource.model.modelname,
                 widgetName: field,
                 modelId: id
             });
         }
     }
-    const props = inertiaAddHelper(req, entity, fields, record);
+    const props = inertiaAddHelper(req, modelResource, fields, record);
     if (req.query?.without_layout) {
         return res.json({
             props: props

package/controllers/editGroup.d.ts

@@ -1 +1 @@
-export default function editGroup(req: ReqType, res: ResType): Promise<void | import("express").Response<any, Record<string, any>>>;
+export default function editGroup(req: ReqType, res: ResType): Promise<import("express").Response<any, Record<string, any>>>;

package/controllers/editGroup.js

@@ -1,33 +1,25 @@
 import { ControllerHelper } from "../helpers/controllerHelper.js";
 import { Adminizer } from "../lib/Adminizer.js";
 import { inertiaGroupHelper } from "../helpers/inertiaGroupHelper.js";
-import { redirectToLogin } from '../helpers/inertiaAutHelper.js';
 export default async function editGroup(req, res) {
-    let entity = ControllerHelper.findEntityObject(req);
-    if (req.adminizer.config.auth.enable) {
-        if (!req.user) {
-            return redirectToLogin(req, res);
-        }
-        else if (!req.adminizer.accessRightsHelper.hasPermission(`update-${entity.name}-model`, req.user)) {
-            return res.sendStatus(403);
-        }
-    }
+    let modelResource = ControllerHelper.findModelResource(req);
+    const internalUsers = req.adminizer.modelHandler.internal("users");
+    const userModel = internalUsers.get("UserAP");
+    const groupModel = internalUsers.get("GroupAP");
     //Check id
     if (!req.params.id) {
         return res.status(404).send({ error: 'Not Found' });
     }
     let users;
     try {
-        // TODO refactor CRUD functions for DataAccessor usage
-        users = await req.adminizer.modelHandler.model.get("UserAP")["_find"](({ isAdministrator: false }));
+        users = await userModel.find({ where: { isAdministrator: false } });
     }
     catch (e) {
         Adminizer.log.error(e);
     }
     let group;
     try {
-        // TODO refactor CRUD functions for DataAccessor usage
-        group = await req.adminizer.modelHandler.model.get("GroupAP")["_findOne"]({ id: req.params.id });
+        group = await groupModel.findOne({ where: { id: Number(req.params.id) } });
     }
     catch (e) {
         Adminizer.log.error('Admin edit error: ');
@@ -62,8 +54,7 @@ export default async function editGroup(req, res) {
         }
         let updatedGroup;
         try {
-            // TODO refactor CRUD functions for DataAccessor usage
-            updatedGroup = await req.adminizer.modelHandler.model.get("GroupAP")["_updateOne"]({ id: group.id }, {
+            updatedGroup = await groupModel.updateOne({ where: { id: group.id } }, {
                 name: req.body.name, description: req.body.description,
                 users: usersInThisGroup, tokens: tokensOfThisGroup
             });
@@ -79,8 +70,7 @@ export default async function editGroup(req, res) {
     }
     if (reloadNeeded) {
         try {
-            // TODO refactor CRUD functions for DataAccessor usage
-            group = await req.adminizer.modelHandler.model.get("GroupAP")["_findOne"]({ id: req.params.id });
+            group = await groupModel.findOne({ where: { id: Number(req.params.id) } });
         }
         catch (e) {
             Adminizer.log.error('Admin edit error: ');
@@ -88,14 +78,13 @@ export default async function editGroup(req, res) {
             return res.status(500).send({ error: 'Internal Server Error' });
         }
         try {
-            // TODO refactor CRUD functions for DataAccessor usage
-            users = await req.adminizer.modelHandler.model.get("UserAP")["_find"]({ isAdministrator: false });
+            users = await userModel.find({ where: { isAdministrator: false } });
         }
         catch (e) {
             Adminizer.log.error(e);
         }
     }
-    const props = inertiaGroupHelper(entity, req, users, groupedTokens, group);
+    const props = inertiaGroupHelper(modelResource, req, users, groupedTokens, group);
     return req.Inertia.render({
         component: 'add-group',
         props: props

package/controllers/editUser.d.ts

@@ -1 +1 @@
-export default function (req: ReqType, res: ResType): Promise<void | import("express").Response<any, Record<string, any>>>;
+export default function (req: ReqType, res: ResType): Promise<import("express").Response<any, Record<string, any>>>;

package/controllers/editUser.js

@@ -2,25 +2,18 @@ import { ControllerHelper } from "../helpers/controllerHelper.js";
 import { Adminizer } from "../lib/Adminizer.js";
 import { generate } from "password-hash";
 import { inertiaUserHelper } from "../helpers/inertiaUserHelper.js";
-import { redirectToLogin } from '../helpers/inertiaAutHelper.js';
 export default async function (req, res) {
-    let entity = ControllerHelper.findEntityObject(req);
-    if (req.adminizer.config.auth.enable) {
-        if (!req.user) {
-            return redirectToLogin(req, res);
-        }
-        else if (!req.adminizer.accessRightsHelper.hasPermission(`update-${entity.name}-model`, req.user)) {
-            return res.sendStatus(403);
-        }
-    }
+    let modelResource = ControllerHelper.findModelResource(req);
+    const internalUsers = req.adminizer.modelHandler.internal("users");
+    const userModel = internalUsers.get("UserAP");
+    const groupModel = internalUsers.get("GroupAP");
     // Check id
     if (!req.params.id) {
         return res.status(404).send({ error: 'Not Found' });
     }
     let user;
     try {
-        // TODO refactor CRUD functions for DataAccessor usage
-        user = await req.adminizer.modelHandler.model.get("UserAP")["_findOne"]({ id: req.params.id });
+        user = await userModel.findOne({ where: { id: Number(req.params.id) } });
     }
     catch (e) {
         Adminizer.log.error('Admin edit error: ');
@@ -29,8 +22,7 @@ export default async function (req, res) {
     }
     let groups;
     try {
-        // TODO refactor CRUD functions for DataAccessor usage
-        groups = await req.adminizer.modelHandler.model.get("GroupAP")["_find"]({});
+        groups = await groupModel.find({});
     }
     catch (e) {
         Adminizer.log.error(e);
@@ -55,8 +47,7 @@ export default async function (req, res) {
         }
         let updatedUser;
         try {
-            // TODO refactor CRUD functions for DataAccessor usage
-            updatedUser = await req.adminizer.modelHandler.model.get("UserAP")["_updateOne"]({ id: user.id }, {
+            updatedUser = await userModel.updateOne({ where: { id: user.id } }, {
                 login: req.body.login, fullName: req.body.fullName,
                 email: req.body.email, timezone: req.body.timezone, expires: req.body.date,
                 locale: locale, isAdministrator: isAdministrator, isConfirmed: isConfirmed, groups: userGroups
@@ -64,8 +55,7 @@ export default async function (req, res) {
             if (req.body.userPassword) {
                 let passwordHashed = generate(req.body.login + req.body.userPassword + process.env.AP_PASSWORD_SALT);
                 let password = 'masked';
-                // TODO refactor CRUD functions for DataAccessor usage
-                updatedUser = await req.adminizer.modelHandler.model.get("UserAP")["_updateOne"]({ id: user.id }, {
+                updatedUser = await userModel.updateOne({ where: { id: user.id } }, {
                     login: req.body.login,
                     passwordHashed: passwordHashed
                 });
@@ -82,8 +72,7 @@ export default async function (req, res) {
     }
     if (reloadNeeded) {
         try {
-            // TODO refactor CRUD functions for DataAccessor usage
-            user = await req.adminizer.modelHandler.model.get("UserAP")["_findOne"]({ id: req.params.id });
+            user = await userModel.findOne({ where: { id: Number(req.params.id) } });
         }
         catch (e) {
             Adminizer.log.error('Admin edit error: ');
@@ -91,14 +80,13 @@ export default async function (req, res) {
             return res.status(500).send({ error: 'Internal Server Error' });
         }
         try {
-            // TODO refactor CRUD functions for DataAccessor usage
-            groups = await req.adminizer.modelHandler.model.get("GroupAP")["_find"]({});
+            groups = await groupModel.find({});
         }
         catch (e) {
             Adminizer.log.error(e);
         }
     }
-    const props = inertiaUserHelper(entity, req, groups, user);
+    const props = inertiaUserHelper(modelResource, req, groups, user);
     return req.Inertia.render({
         component: 'add-user',
         props: props

package/controllers/exportData.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Main export controller
+ * POST /adminizer/model/:model/export
+ * Body: { filterId, format, fields }
+ */
+export default function exportData(req: ReqType, res: ResType): Promise<ResType>;

package/controllers/exportData.js

@@ -0,0 +1,315 @@
+import { ControllerHelper } from "../helpers/controllerHelper.js";
+import { DataAccessor } from "../lib/DataAccessor.js";
+import { ListQueryBuilder } from "../lib/list-query-builder/ListQueryBuilder.js";
+import { Adminizer } from "../lib/Adminizer.js";
+import { FilterService } from "../lib/filters/FilterService.js";
+import { convertDatetimeConditions } from "../helpers/filterDatetimeHelper.js";
+/**
+ * Main export controller
+ * POST /adminizer/model/:model/export
+ * Body: { filterId, format, fields }
+ */
+export default async function exportData(req, res) {
+    const modelResource = ControllerHelper.findModelResource(req);
+    if (!modelResource.model) {
+        return res.status(404).json({ error: 'Model not found' });
+    }
+    const { filterId, format, selectedFields: bodySelectedFields } = req.body;
+    // Validate format
+    const exportFormat = format || 'json';
+    if (!['json', 'csv', 'xlsx'].includes(exportFormat)) {
+        return res.status(400).json({ error: 'Invalid export format. Supported: json, csv, xlsx' });
+    }
+    const dataAccessor = new DataAccessor(req.adminizer, req.user, modelResource, "list");
+    const fields = dataAccessor.getFieldsConfig();
+    // Load filter if provided
+    let filters = [];
+    let savedColumns = [];
+    if (filterId) {
+        try {
+            if (filterId === 'temporary' && req.session?.temporaryFilters?.[modelResource.name]) {
+                const tempFilter = req.session.temporaryFilters[modelResource.name];
+                filters = convertDatetimeConditions(tempFilter.conditions || [], { dropEmptyValues: true });
+                if (tempFilter.columns && Array.isArray(tempFilter.columns)) {
+                    savedColumns = tempFilter.columns.map((col, index) => ({
+                        id: index + 1,
+                        filter: 'temporary',
+                        fieldName: col.fieldName,
+                        order: col.order !== undefined ? col.order : index
+                    }));
+                }
+            }
+            else if (filterId !== 'temporary') {
+                const filterService = new FilterService(req.adminizer);
+                const result = await filterService.getFilterWithColumns(filterId, req.user);
+                if (result.filter && result.filter.conditions) {
+                    filters = convertDatetimeConditions(result.filter.conditions, { dropEmptyValues: true });
+                }
+                savedColumns = result.columns || [];
+            }
+        }
+        catch (err) {
+            Adminizer.log.error('Error loading filter for export:', err);
+            return res.status(500).json({ error: 'Error loading filter' });
+        }
+    }
+    // Determine fields to export
+    let displayFields = fields;
+    // Apply selected fields from request body
+    if (bodySelectedFields && Array.isArray(bodySelectedFields) && bodySelectedFields.length > 0) {
+        const validFields = bodySelectedFields.filter(f => fields[f]);
+        if (validFields.length > 0) {
+            displayFields = validFields.reduce((acc, key) => {
+                if (fields[key]) {
+                    acc[key] = fields[key];
+                }
+                return acc;
+            }, {});
+        }
+    }
+    // Apply custom columns from filter
+    if (savedColumns.length > 0) {
+        displayFields = applyCustomColumnsForExport(displayFields, savedColumns);
+    }
+    // Fetch ALL data (no pagination)
+    const queryParams = {
+        page: 1,
+        limit: 10000, // Large limit to get all records
+        filters: filters.length > 0 ? filters : undefined,
+        sort: 'id',
+        sortDirection: 'ASC',
+        fields: Object.keys(displayFields)
+    };
+    const listQueryBuilder = new ListQueryBuilder(modelResource.model, fields, dataAccessor, req.adminizer.customFilterHandler);
+    try {
+        const result = await listQueryBuilder.execute(queryParams);
+        const records = result.data;
+        // Prepare human-readable data for export
+        const exportData = prepareExportData(records, displayFields, req);
+        // Generate file based on format
+        switch (exportFormat) {
+            case 'json':
+                return sendJsonExport(res, exportData, modelResource.name);
+            case 'csv':
+                return sendCsvExport(res, exportData, modelResource.name, displayFields, req);
+            case 'xlsx':
+                return sendXlsxExport(res, exportData, modelResource.name, displayFields, req);
+            default:
+                return res.status(400).json({ error: 'Invalid export format' });
+        }
+    }
+    catch (err) {
+        Adminizer.log.error('Export error:', err);
+        return res.status(500).json({ error: 'Export failed', message: err.message });
+    }
+}
+/**
+ * Apply custom column configuration for export
+ */
+function applyCustomColumnsForExport(fields, columns) {
+    const sortedColumns = [...columns].sort((a, b) => (a.order || 0) - (b.order || 0));
+    const visibleColumns = sortedColumns.filter(col => fields[col.fieldName]);
+    if (visibleColumns.length === 0) {
+        return fields;
+    }
+    const result = {};
+    for (const col of visibleColumns) {
+        if (fields[col.fieldName]) {
+            result[col.fieldName] = fields[col.fieldName];
+        }
+    }
+    return result;
+}
+/**
+ * Prepare data for export - convert values to human-readable format
+ */
+function prepareExportData(records, displayFields, req) {
+    return records.map(record => {
+        const row = {};
+        for (const [key, field] of Object.entries(displayFields)) {
+            const fieldConfig = field;
+            const config = fieldConfig.config;
+            const title = (typeof config === 'object' && config !== null && config.title)
+                ? req.i18n.__(config.title)
+                : key;
+            const value = record[key];
+            // Format value based on field type
+            row[title] = formatExportValue(value, fieldConfig);
+        }
+        return row;
+    });
+}
+/**
+ * Format value for export based on type
+ */
+function formatExportValue(value, field) {
+    if (value === null || value === undefined) {
+        return '';
+    }
+    const fieldType = field.model?.type;
+    // Handle relationships
+    if (field.model?.model) {
+        const displayField = field.modelConfig?.titleField ??
+            (typeof value === 'object' && value ? (value.title || value.name || value.id) : value);
+        return typeof displayField === 'object' ? JSON.stringify(displayField) : String(displayField);
+    }
+    // Handle associations (hasMany)
+    if (fieldType === 'association-many' || fieldType === 'association') {
+        if (Array.isArray(value)) {
+            return value.map((item) => {
+                if (typeof item === 'object' && item) {
+                    return item.title || item.name || item.id || JSON.stringify(item);
+                }
+                return String(item);
+            }).join(', ');
+        }
+        return String(value);
+    }
+    // Handle JSON fields
+    if (fieldType === 'json') {
+        if (typeof value === 'object') {
+            return JSON.stringify(value, null, 2);
+        }
+        return String(value);
+    }
+    // Handle boolean
+    if (fieldType === 'boolean') {
+        return value ? 'Yes' : 'No';
+    }
+    // Handle dates
+    if (fieldType === 'date' || fieldType === 'datetime') {
+        if (value instanceof Date) {
+            return value.toISOString();
+        }
+        return String(value);
+    }
+    // Handle arrays
+    if (Array.isArray(value)) {
+        return value.join(', ');
+    }
+    // Default: convert to string
+    return String(value);
+}
+/**
+ * Send JSON export response
+ */
+function sendJsonExport(res, data, modelName) {
+    const filename = `${modelName}_export_${Date.now()}.json`;
+    res.setHeader('Content-Type', 'application/json');
+    res.setHeader('Content-Disposition', `attachment; filename="${filename}"`);
+    res.setHeader('Content-Length', Buffer.byteLength(JSON.stringify(data, null, 2)));
+    return res.json(data);
+}
+/**
+ * Escape value for CSV
+ */
+function escapeCsvValue(value) {
+    if (value === null || value === undefined) {
+        return '';
+    }
+    const str = String(value);
+    // If value contains comma, newline, or quote, wrap in quotes
+    if (str.includes(',') || str.includes('\n') || str.includes('"') || str.includes('\r')) {
+        return `"${str.replace(/"/g, '""')}"`;
+    }
+    return str;
+}
+/**
+ * Send CSV export response
+ */
+function sendCsvExport(res, data, modelName, fields, req) {
+    const filename = `${modelName}_export_${Date.now()}.csv`;
+    // Get headers (preserve order from fields)
+    const headers = Object.keys(fields).map(key => {
+        const field = fields[key];
+        const config = field.config;
+        return (typeof config === 'object' && config !== null && config.title)
+            ? req.i18n.__(config.title)
+            : key;
+    });
+    // Build CSV content
+    const csvRows = [];
+    // Add BOM for Excel compatibility with UTF-8
+    const bom = '\uFEFF';
+    // Header row
+    csvRows.push(headers.map(h => escapeCsvValue(h)).join(','));
+    // Data rows
+    for (const row of data) {
+        const values = headers.map(header => {
+            const value = row[header];
+            return escapeCsvValue(value);
+        });
+        csvRows.push(values.join(','));
+    }
+    const csvContent = bom + csvRows.join('\r\n');
+    const buffer = Buffer.from(csvContent, 'utf-8');
+    res.setHeader('Content-Type', 'text/csv; charset=utf-8');
+    res.setHeader('Content-Disposition', `attachment; filename="${filename}"`);
+    res.setHeader('Content-Length', buffer.length);
+    return res.send(buffer);
+}
+/**
+ * Send XLSX export response
+ * Uses xlsx library if available
+ */
+async function sendXlsxExport(res, data, modelName, fields, req) {
+    let XLSX;
+    try {
+        XLSX = await import('xlsx');
+    }
+    catch (err) {
+        Adminizer.log.error('xlsx library not installed. Install with: npm install xlsx');
+        return res.status(500).json({
+            error: 'XLSX export requires xlsx library',
+            message: 'Please install xlsx: npm install xlsx'
+        });
+    }
+    const filename = `${modelName}_export_${Date.now()}.xlsx`;
+    // Get headers (preserve order from fields)
+    const headers = Object.keys(fields).map(key => {
+        const field = fields[key];
+        const config = field.config;
+        return (typeof config === 'object' && config !== null && config.title)
+            ? req.i18n.__(config.title)
+            : key;
+    });
+    // Create workbook
+    const wb = XLSX.default.utils.book_new();
+    // Prepare data array with headers
+    const wsData = [headers];
+    // Add rows
+    for (const row of data) {
+        const values = headers.map(header => {
+            const value = row[header];
+            if (value === '' || value === null || value === undefined) {
+                return null;
+            }
+            return value;
+        });
+        wsData.push(values);
+    }
+    // Create worksheet
+    const ws = XLSX.default.utils.aoa_to_sheet(wsData);
+    // Auto-size columns (optional)
+    const colWidths = headers.map((header, i) => {
+        let maxWidth = header.length;
+        for (const row of data) {
+            const val = String(row[header] || '');
+            if (val.length > maxWidth) {
+                maxWidth = val.length;
+            }
+        }
+        // Cap at 50 characters, minimum 10
+        return { wch: Math.min(Math.max(maxWidth + 2, 10), 50) };
+    });
+    ws['!cols'] = colWidths;
+    // Add worksheet to workbook
+    const sheetName = modelName.substring(0, 31); // Excel sheet name limit
+    XLSX.default.utils.book_append_sheet(wb, ws, sheetName);
+    // Generate buffer
+    const buffer = XLSX.default.write(wb, { type: 'buffer', bookType: 'xlsx' });
+    res.setHeader('Content-Type', 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet');
+    res.setHeader('Content-Disposition', `attachment; filename="${filename}"`);
+    res.setHeader('Content-Length', buffer.length);
+    return res.send(buffer);
+}

package/controllers/feed.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Public feed controller — exports data by apiKey with userKey authentication
+ * GET /adminizer/api/feed/:apiKey.json?userKey=xxx
+ * GET /adminizer/api/feed/:apiKey.xml?userKey=xxx
+ */
+export default function feedController(req: ReqType, res: ResType): Promise<ResType>;