adminforth 1.1.107 → 1.2.2

package/dist/index.js

@@ -18,14 +18,12 @@ import MongoConnector from './dataConnectors/mongo.js';
 import PostgresConnector from './dataConnectors/postgres.js';
 import SQLiteConnector from './dataConnectors/sqlite.js';
 import CodeInjector from './modules/codeInjector.js';
-import { guessLabelFromName } from './modules/utils.js';
 import ExpressServer from './servers/express.js';
-import { v1 as uuid } from 'uuid';
-import fs from 'fs';
 import { ADMINFORTH_VERSION, listify } from './modules/utils.js';
-import { AdminForthFilterOperators, AdminForthDataTypes, AdminForthResourcePages, AllowedActionsEnum, ActionCheckSource } from './types/AdminForthConfig.js';
-import path from 'path';
+import { AdminForthFilterOperators, AdminForthDataTypes, AdminForthResourcePages } from './types/AdminForthConfig.js';
 import AdminForthPlugin from './basePlugin.js';
+import ConfigValidator from './modules/configValidator.js';
+import AdminForthRestAPI from './modules/restApi.js';
 //get array from enum AdminForthResourcePages
 export { AdminForthPlugin };
 class AdminForth {
@@ -35,14 +33,18 @@ class AdminForth {
         });
         this.config = Object.assign(Object.assign({}, __classPrivateFieldGet(this, _AdminForth_defaultConfig, "f")), config);
         this.codeInjector = new CodeInjector(this);
+        this.configValidator = new ConfigValidator(this, this.config);
+        this.restApi = new AdminForthRestAPI(this);
         this.activatedPlugins = [];
-        this.validateConfig();
+        this.configValidator.validateConfig();
         this.activatePlugins();
-        this.validateConfig(); // revalidate after plugins
+        this.configValidator.validateConfig(); // revalidate after plugins
         this.express = new ExpressServer(this);
         this.auth = new AdminForthAuth(this);
         this.connectors = {};
-        this.statuses = {};
+        this.statuses = {
+            dbDiscover: 'running',
+        };
         console.log(`🚀 AdminForth v${ADMINFORTH_VERSION} starting up`);
     }
     activatePlugins() {
@@ -54,392 +56,6 @@ class AdminForth {
         }
         ;
     }
-    checkCustomFileExists(filePath) {
-        if (filePath.startsWith('@@/')) {
-            const checkPath = path.join(this.config.customization.customComponentsDir, filePath.replace('@@/', ''));
-            if (!fs.existsSync(checkPath)) {
-                return [`File file ${filePath} does not exist in ${this.config.customization.customComponentsDir}`];
-            }
-        }
-        return [];
-    }
-    validateComponent(component, errors, ignoreExistsCheck = false) {
-        if (!component) {
-            return component;
-        }
-        let obj;
-        if (typeof component === 'string') {
-            obj = { file: component, meta: {} };
-        }
-        else {
-            obj = component;
-        }
-        if (!ignoreExistsCheck) {
-            errors.push(...this.checkCustomFileExists(obj.file));
-        }
-        return obj;
-    }
-    validateConfig() {
-        var _b;
-        const errors = [];
-        if (this.config.rootUser) {
-            if (!this.config.rootUser.username) {
-                throw new Error('rootUser.username is required');
-            }
-            if (!this.config.rootUser.password) {
-                throw new Error('rootUser.password is required');
-            }
-            console.log('\n ⚠️⚠️⚠️ [INSECURE ALERT] config.rootUser is set, please create a new user and remove config.rootUser from config ASAP when you are in production\n');
-        }
-        if (!this.config.customization.customComponentsDir) {
-            this.config.customization.customComponentsDir = './custom';
-        }
-        try {
-            // check customComponentsDir exists
-            fs.accessSync(this.config.customization.customComponentsDir, fs.constants.R_OK);
-        }
-        catch (e) {
-            this.config.customization.customComponentsDir = undefined;
-        }
-        if (!this.config.auth) {
-            if (!this.config.auth.resourceId) {
-                throw new Error('No config.auth.resourceId defined');
-            }
-            if (!this.config.auth.passwordHashField) {
-                throw new Error('No config.auth.passwordHashField defined');
-            }
-            if (!this.config.auth.usernameField) {
-                throw new Error('No config.auth.usernameField defined');
-            }
-            if (this.config.auth.loginBackgroundImage) {
-                errors.push(...this.checkCustomFileExists(this.config.auth.loginBackgroundImage));
-            }
-            const userResource = this.config.resources.find((res) => res.resourceId === this.config.auth.resourceId);
-            if (!userResource) {
-                throw new Error(`Resource with id "${this.config.auth.resourceId}" not found`);
-            }
-            if (!this.config.auth.beforeLoginConfirmation) {
-                this.config.auth.beforeLoginConfirmation = [];
-            }
-        }
-        if (!this.config.customization) {
-            this.config.customization = {};
-        }
-        if (!this.config.customization.customComponentsDir) {
-            this.config.customization.customComponentsDir = './custom';
-        }
-        try {
-            // check customComponentsDir exists
-            fs.accessSync(this.config.customization.customComponentsDir, fs.constants.R_OK);
-        }
-        catch (e) {
-            this.config.customization.customComponentsDir = undefined;
-        }
-        if (this.config.customization.customPages) {
-            this.config.customization.customPages.forEach((page, i) => {
-                // validate component if it's not plugin injection
-                if (this.codeInjector.allComponentNames.hasOwnProperty(page.component)) {
-                    const validatedPage = this.validateComponent(page.component, errors, true);
-                }
-            });
-        }
-        else {
-            this.config.customization.customPages = [];
-        }
-        if (!this.config.baseUrl) {
-            this.config.baseUrl = '';
-        }
-        if (!this.config.baseUrl.endsWith('/')) {
-            this.baseUrlSlashed = this.config.baseUrl + '/';
-        }
-        else {
-            this.baseUrlSlashed = this.config.baseUrl;
-        }
-        if (((_b = this.config) === null || _b === void 0 ? void 0 : _b.customization.brandName) === undefined) {
-            this.config.customization.brandName = 'AdminForth';
-        }
-        if (this.config.customization.brandLogo) {
-            errors.push(...this.checkCustomFileExists(this.config.customization.brandLogo));
-        }
-        if (this.config.customization.favicon) {
-            errors.push(...this.checkCustomFileExists(this.config.customization.favicon));
-        }
-        if (!this.config.customization.datesFormat) {
-            this.config.customization.datesFormat = 'MMM D, YYYY HH:mm:ss';
-        }
-        if (this.config.resources) {
-            this.config.resources.forEach((res) => {
-                var _b, _c, _d;
-                if (!res.table) {
-                    errors.push(`Resource "${res.dataSource}" is missing table`);
-                }
-                // if recordLabel is not callable, throw error
-                if (res.recordLabel && typeof res.recordLabel !== 'function') {
-                    errors.push(`Resource "${res.dataSource}" recordLabel is not a function`);
-                }
-                if (!res.recordLabel) {
-                    res.recordLabel = (item) => {
-                        const pkVal = item[res.columns.find((col) => col.primaryKey).name];
-                        return `${res.label} ${pkVal}`;
-                    };
-                }
-                res.resourceId = res.resourceId || res.table;
-                res.label = res.label || res.table.charAt(0).toUpperCase() + res.table.slice(1);
-                if (!res.dataSource) {
-                    errors.push(`Resource "${res.resourceId}" is missing dataSource`);
-                }
-                if (!res.columns) {
-                    res.columns = [];
-                }
-                res.columns.forEach((col) => {
-                    var _b, _c, _d, _e;
-                    col.label = col.label || guessLabelFromName(col.name);
-                    //define default sortable
-                    if (!Object.keys(col).includes('sortable')) {
-                        col.sortable = true;
-                    }
-                    if (col.showIn && !Array.isArray(col.showIn)) {
-                        errors.push(`Resource "${res.resourceId}" column "${col.name}" showIn must be an array`);
-                    }
-                    // check col.required is string or object
-                    if (col.required && !((typeof col.required === 'boolean') || (typeof col.required === 'object'))) {
-                        errors.push(`Resource "${res.resourceId}" column "${col.name}" required must be a string or object`);
-                    }
-                    // if it is object check the keys are one of ['create', 'edit']
-                    if (typeof col.required === 'object') {
-                        const wrongRequiredOn = Object.keys(col.required).find((c) => !['create', 'edit'].includes(c));
-                        if (wrongRequiredOn) {
-                            errors.push(`Resource "${res.resourceId}" column "${col.name}" has invalid required value "${wrongRequiredOn}", allowed keys are 'create', 'edit']`);
-                        }
-                    }
-                    // same for editingNote
-                    if (col.editingNote && !((typeof col.editingNote === 'string') || (typeof col.editingNote === 'object'))) {
-                        errors.push(`Resource "${res.resourceId}" column "${col.name}" editingNote must be a string or object`);
-                    }
-                    if (typeof col.editingNote === 'object') {
-                        const wrongEditingNoteOn = Object.keys(col.editingNote).find((c) => !['create', 'edit'].includes(c));
-                        if (wrongEditingNoteOn) {
-                            errors.push(`Resource "${res.resourceId}" column "${col.name}" has invalid editingNote value "${wrongEditingNoteOn}", allowed keys are 'create', 'edit']`);
-                        }
-                    }
-                    const wrongShowIn = col.showIn && col.showIn.find((c) => AdminForthResourcePages[c] === undefined);
-                    if (wrongShowIn) {
-                        errors.push(`Resource "${res.resourceId}" column "${col.name}" has invalid showIn value "${wrongShowIn}", allowed values are ${Object.keys(AdminForthResourcePages).join(', ')}`);
-                    }
-                    col.showIn = col.showIn || Object.values(AdminForthResourcePages);
-                    if (col.foreignResource) {
-                        const befHook = (_c = (_b = col.foreignResource.hooks) === null || _b === void 0 ? void 0 : _b.dropdownList) === null || _c === void 0 ? void 0 : _c.beforeDatasourceRequest;
-                        if (befHook) {
-                            if (!Array.isArray(befHook)) {
-                                col.foreignResource.hooks.dropdownList.beforeDatasourceRequest = [befHook];
-                            }
-                        }
-                        const aftHook = (_e = (_d = col.foreignResource.hooks) === null || _d === void 0 ? void 0 : _d.dropdownList) === null || _e === void 0 ? void 0 : _e.afterDatasourceResponse;
-                        if (aftHook) {
-                            if (!Array.isArray(aftHook)) {
-                                col.foreignResource.hooks.dropdownList.afterDatasourceResponse = [aftHook];
-                            }
-                        }
-                    }
-                });
-                if (!res.options) {
-                    res.options = { bulkActions: [], allowedActions: {} };
-                }
-                if (!res.options.allowedActions) {
-                    res.options.allowedActions = {
-                        all: true,
-                    };
-                }
-                if (Object.keys(res.options.allowedActions).includes('all')) {
-                    if (Object.keys(res.options.allowedActions).length > 1) {
-                        errors.push(`Resource "${res.resourceId}" allowedActions cannot have "all" and other keys at same time: ${Object.keys(res.options.allowedActions).join(', ')}`);
-                    }
-                    for (const key of Object.keys(AllowedActionsEnum)) {
-                        if (key !== 'all') {
-                            res.options.allowedActions[key] = res.options.allowedActions.all;
-                        }
-                    }
-                    delete res.options.allowedActions.all;
-                }
-                else {
-                    // by default allow all actions
-                    for (const key of Object.keys(AllowedActionsEnum)) {
-                        if (!Object.keys(res.options.allowedActions).includes(key)) {
-                            res.options.allowedActions[key] = true;
-                        }
-                    }
-                }
-                //check if resource has bulkActions
-                let bulkActions = ((_b = res === null || res === void 0 ? void 0 : res.options) === null || _b === void 0 ? void 0 : _b.bulkActions) || [];
-                if (!Array.isArray(bulkActions)) {
-                    errors.push(`Resource "${res.resourceId}" bulkActions must be an array`);
-                    bulkActions = [];
-                }
-                if (((_d = (_c = res.options) === null || _c === void 0 ? void 0 : _c.allowedActions) === null || _d === void 0 ? void 0 : _d.delete) && !bulkActions.find((action) => action.label === 'Delete checked')) {
-                    bulkActions.push({
-                        label: `Delete checked`,
-                        state: 'danger',
-                        icon: 'flowbite:trash-bin-outline',
-                        action: (_e) => __awaiter(this, [_e], void 0, function* ({ selectedIds }) {
-                            const connector = this.connectors[res.dataSource];
-                            yield Promise.all(selectedIds.map((recordId) => __awaiter(this, void 0, void 0, function* () {
-                                yield connector.deleteRecord({ resource: res, recordId });
-                            })));
-                        })
-                    });
-                }
-                const newBulkActions = bulkActions.map((action) => {
-                    return Object.assign(action, { id: uuid() });
-                });
-                res.options.bulkActions = newBulkActions;
-                // if pageInjection is a string, make array with one element. Also check file exists
-                const possibleInjections = ['beforeBreadcrumbs', 'afterBreadcrumbs', 'bottom'];
-                if (res.options.pageInjections) {
-                    Object.entries(res.options.pageInjections).map(([key, value]) => {
-                        Object.entries(value).map(([injection, target]) => {
-                            if (possibleInjections.includes(injection)) {
-                                if (!Array.isArray(res.options.pageInjections[key][injection])) {
-                                    // not array
-                                    res.options.pageInjections[key][injection] = [target];
-                                }
-                                res.options.pageInjections[key][injection].forEach((target, i) => {
-                                    res.options.pageInjections[key][injection][i] = this.validateComponent(target, errors);
-                                });
-                            }
-                            else {
-                                errors.push(`Resource "${res.resourceId}" has invalid pageInjection key "${injection}", Supported keys are ${possibleInjections.join(', ')}`);
-                            }
-                        });
-                    });
-                }
-                // transform all hooks Functions to array of functions
-                if (!res.hooks) {
-                    res.hooks = {};
-                }
-                for (const hookName of ['show', 'list']) {
-                    if (!res.hooks[hookName]) {
-                        res.hooks[hookName] = {};
-                    }
-                    if (!res.hooks[hookName].beforeDatasourceRequest) {
-                        res.hooks[hookName].beforeDatasourceRequest = [];
-                    }
-                    if (!Array.isArray(res.hooks[hookName].beforeDatasourceRequest)) {
-                        res.hooks[hookName].beforeDatasourceRequest = [res.hooks[hookName].beforeDatasourceRequest];
-                    }
-                    if (!res.hooks[hookName].afterDatasourceResponse) {
-                        res.hooks[hookName].afterDatasourceResponse = [];
-                    }
-                    if (!Array.isArray(res.hooks[hookName].afterDatasourceResponse)) {
-                        res.hooks[hookName].afterDatasourceResponse = [res.hooks[hookName].afterDatasourceResponse];
-                    }
-                }
-                for (const hookName of ['create', 'edit', 'delete']) {
-                    if (!res.hooks[hookName]) {
-                        res.hooks[hookName] = {};
-                    }
-                    if (!res.hooks[hookName].beforeSave) {
-                        res.hooks[hookName].beforeSave = [];
-                    }
-                    if (!Array.isArray(res.hooks[hookName].beforeSave)) {
-                        res.hooks[hookName].beforeSave = [res.hooks[hookName].beforeSave];
-                    }
-                    if (!res.hooks[hookName].afterSave) {
-                        res.hooks[hookName].afterSave = [];
-                    }
-                    if (!Array.isArray(res.hooks[hookName].afterSave)) {
-                        res.hooks[hookName].afterSave = [res.hooks[hookName].afterSave];
-                    }
-                }
-            });
-            if (!this.config.menu) {
-                errors.push('No config.menu defined');
-            }
-            // check if there is only one homepage: true in menu, recursivly
-            let homepages = 0;
-            const browseMenu = (menu) => {
-                menu.forEach((item) => {
-                    if (item.component && item.resourceId) {
-                        errors.push(`Menu item cannot have both component and resourceId: ${JSON.stringify(item)}`);
-                    }
-                    if (item.component && !item.path) {
-                        errors.push(`Menu item with component must have path : ${JSON.stringify(item)}`);
-                    }
-                    if (item.type === 'resource' && !item.resourceId) {
-                        errors.push(`Menu item with type 'resource' must have resourceId : ${JSON.stringify(item)}`);
-                    }
-                    if (item.resourceId && !this.config.resources.find((res) => res.resourceId === item.resourceId)) {
-                        errors.push(`Menu item with type 'resourceId' has resourceId which is not in resources: ${JSON.stringify(item)}`);
-                    }
-                    if (item.type === 'component' && !item.component) {
-                        errors.push(`Menu item with type 'component' must have component : ${JSON.stringify(item)}`);
-                    }
-                    // make sure component starts with @@
-                    if (item.component) {
-                        if (!item.component.startsWith('@@')) {
-                            errors.push(`Menu item component must start with @@ : ${JSON.stringify(item)}`);
-                        }
-                        const path = item.component.replace('@@', this.config.customization.customComponentsDir);
-                        if (!fs.existsSync(path)) {
-                            errors.push(`Menu item component "${item.component.replace('@@', '')}" does not exist in "${this.config.customization.customComponentsDir}"`);
-                        }
-                    }
-                    if (item.homepage) {
-                        homepages++;
-                        if (homepages > 1) {
-                            errors.push('There must be only one homepage: true in menu, found second one in ' + JSON.stringify(item));
-                        }
-                    }
-                    if (item.children) {
-                        browseMenu(item.children);
-                    }
-                });
-            };
-            browseMenu(this.config.menu);
-        }
-        // check for duplicate resourceIds and show which ones are duplicated
-        const resourceIds = this.config.resources.map((res) => res.resourceId);
-        const uniqueResourceIds = new Set(resourceIds);
-        if (uniqueResourceIds.size != resourceIds.length) {
-            const duplicates = resourceIds.filter((item, index) => resourceIds.indexOf(item) != index);
-            errors.push(`Duplicate fields "resourceId" or "table": ${duplicates.join(', ')}`);
-        }
-        //add ids for onSelectedAllActions for each resource
-        if (errors.length > 0) {
-            throw new Error(`Invalid AdminForth config: ${errors.join(', ')}`);
-        }
-        // check is all custom components files exists
-        for (const resource of this.config.resources) {
-            for (const column of resource.columns) {
-                if (column.components) {
-                    for (const [key, comp] of Object.entries(column.components)) {
-                        let ignoreExistsCheck = false;
-                        if (this.codeInjector.allComponentNames[comp.file]) {
-                            // not obvious, but if we are in this if, it means that this is plugin component
-                            // and there is no sense to check if it exists in users folder
-                            ignoreExistsCheck = true;
-                        }
-                        column.components[key] = this.validateComponent(comp, errors, ignoreExistsCheck);
-                    }
-                }
-            }
-        }
-    }
-    postProcessAfterDiscover(resource) {
-        resource.columns.forEach((column) => {
-            // if db/user says column is required in boolean, exapd
-            if (typeof column.required === 'boolean') {
-                column.required = { create: column.required, edit: column.required };
-            }
-            if (!column.required) {
-                column.required = { create: false, edit: false };
-            }
-            // same for editingNote
-            if (typeof column.editingNote === 'string') {
-                column.editingNote = { create: column.editingNote, edit: column.editingNote };
-            }
-        });
-        resource.dataSourceColumns = resource.columns.filter((col) => !col.virtual);
-    }
     discoverDatabases() {
         return __awaiter(this, void 0, void 0, function* () {
             this.statuses.dbDiscover = 'running';
@@ -476,7 +92,7 @@ class AdminForth {
                     // first find discovered values, but allow override
                     res.columns[i] = Object.assign(Object.assign({}, fieldTypes[col.name]), col);
                 });
-                this.postProcessAfterDiscover(res);
+                this.configValidator.postProcessAfterDiscover(res);
                 // check if primaryKey column is present
                 if (!res.columns.some((col) => col.primaryKey)) {
                     throw new Error(`Resource '${res.table}' has no column defined or auto-discovered. Please set 'primaryKey: true' in a columns which has unique value for each record and index`);
@@ -520,7 +136,9 @@ class AdminForth {
                         });
                     }
                 }
-                if (((_c = column.required) === null || _c === void 0 ? void 0 : _c.create) && record[column.name] === undefined) {
+                if (((_c = column.required) === null || _c === void 0 ? void 0 : _c.create) &&
+                    record[column.name] === undefined &&
+                    column.showIn.includes(AdminForthResourcePages.create)) {
                     return { error: `Column '${column.name}' is required` };
                 }
                 if (column.isUnique) {
@@ -553,6 +171,7 @@ class AdminForth {
                 }
             }
             const connector = this.connectors[resource.dataSource];
+            process.env.HEAVY_DEBUG && console.log('🪲🪲🪲🪲 creating record createResourceRecord', record);
             yield connector.createRecord({ resource, record });
             // execute hook if needed
             for (const hook of listify((_g = (_f = resource.hooks) === null || _f === void 0 ? void 0 : _f.create) === null || _g === void 0 ? void 0 : _g.afterSave)) {
@@ -565,612 +184,11 @@ class AdminForth {
                     return { error: resp.error };
                 }
             }
+            return { ok: true };
         });
     }
     setupEndpoints(server) {
-        server.endpoint({
-            noAuth: true,
-            method: 'POST',
-            path: '/login',
-            handler: (_b) => __awaiter(this, [_b], void 0, function* ({ body, response }) {
-                var _c, _d, _e, _f;
-                const INVALID_MESSAGE = 'Invalid username or password';
-                const { username, password } = body;
-                let adminUser;
-                let toReturn = { ok: true, allowedLogin: true };
-                let token;
-                if (username === this.config.rootUser.username && password === this.config.rootUser.password) {
-                    this.auth.setAuthCookie({ response, username, pk: null });
-                    adminUser = { isRoot: true, dbUser: null, pk: null, username: this.config.rootUser.username };
-                }
-                else {
-                    // get resource from db
-                    if (!this.config.auth) {
-                        throw new Error('No config.auth defined');
-                    }
-                    const userResource = this.config.resources.find((res) => res.resourceId === this.config.auth.resourceId);
-                    // if there is no passwordHashField, in columns, add it, with backendOnly and showIn: []
-                    if (!userResource.dataSourceColumns.find((col) => col.name === this.config.auth.passwordHashField)) {
-                        userResource.dataSourceColumns.push({
-                            name: this.config.auth.passwordHashField,
-                            backendOnly: true,
-                            showIn: [],
-                            type: _a.Types.STRING,
-                        });
-                        console.log('Adding passwordHashField to userResource', userResource);
-                    }
-                    const userRecord = (_c = (yield this.connectors[userResource.dataSource].getData({
-                        resource: userResource,
-                        filters: [
-                            { field: this.config.auth.usernameField, operator: AdminForthFilterOperators.EQ, value: username },
-                        ],
-                        limit: 1,
-                        offset: 0,
-                        sort: [],
-                    })).data) === null || _c === void 0 ? void 0 : _c[0];
-                    if (!userRecord) {
-                        return { error: 'User not found' };
-                    }
-                    const passwordHash = userRecord[this.config.auth.passwordHashField];
-                    const valid = yield AdminForthAuth.verifyPassword(password, passwordHash);
-                    if (valid) {
-                        adminUser = {
-                            isRoot: false, dbUser: userRecord,
-                            pk: userRecord[userResource.columns.find((col) => col.primaryKey).name],
-                            username,
-                        };
-                        const beforeLoginConfirmation = this.config.auth.beforeLoginConfirmation;
-                        if (beforeLoginConfirmation === null || beforeLoginConfirmation === void 0 ? void 0 : beforeLoginConfirmation.length) {
-                            for (const hook of beforeLoginConfirmation) {
-                                const resp = yield hook({ adminUser, response });
-                                if ((_d = resp === null || resp === void 0 ? void 0 : resp.body) === null || _d === void 0 ? void 0 : _d.redirectTo) {
-                                    toReturn = { ok: resp.ok, redirectTo: (_e = resp === null || resp === void 0 ? void 0 : resp.body) === null || _e === void 0 ? void 0 : _e.redirectTo, allowedLogin: (_f = resp === null || resp === void 0 ? void 0 : resp.body) === null || _f === void 0 ? void 0 : _f.allowedLogin };
-                                    break;
-                                }
-                            }
-                        }
-                        if (toReturn.allowedLogin) {
-                            this.auth.setAuthCookie({ response, username, pk: userRecord[userResource.columns.find((col) => col.primaryKey).name] });
-                        }
-                    }
-                    else {
-                        return { error: INVALID_MESSAGE };
-                    }
-                }
-                return toReturn;
-            })
-        });
-        server.endpoint({
-            method: 'POST',
-            path: '/check_auth',
-            handler: (_g) => __awaiter(this, [_g], void 0, function* ({ adminUser }) {
-                return { ok: true };
-            }),
-        });
-        server.endpoint({
-            noAuth: true,
-            method: 'POST',
-            path: '/logout',
-            handler: (_h) => __awaiter(this, [_h], void 0, function* ({ response }) {
-                this.auth.removeAuthCookie(response);
-                return { ok: true };
-            }),
-        });
-        server.endpoint({
-            noAuth: true,
-            method: 'GET',
-            path: '/get_public_config',
-            handler: (_j) => __awaiter(this, [_j], void 0, function* ({ body }) {
-                var _k;
-                // find resource
-                if (!this.config.auth) {
-                    throw new Error('No config.auth defined');
-                }
-                const usernameField = this.config.auth.usernameField;
-                const resource = this.config.resources.find((res) => res.resourceId === this.config.auth.resourceId);
-                const usernameColumn = resource.columns.find((col) => col.name === usernameField);
-                return {
-                    brandName: this.config.customization.brandName,
-                    usernameFieldName: usernameColumn.label,
-                    loginBackgroundImage: this.config.auth.loginBackgroundImage,
-                    title: (_k = this.config.customization) === null || _k === void 0 ? void 0 : _k.title,
-                };
-            }),
-        });
-        server.endpoint({
-            method: 'GET',
-            path: '/get_base_config',
-            handler: (_l) => __awaiter(this, [_l], void 0, function* ({ input, adminUser, cookies }) {
-                var _m, _o;
-                let username = '';
-                let userFullName = '';
-                if (adminUser.isRoot) {
-                    username = this.config.rootUser.username;
-                }
-                else {
-                    const dbUser = adminUser.dbUser;
-                    username = dbUser[this.config.auth.usernameField];
-                    userFullName = dbUser[this.config.auth.userFullNameField];
-                }
-                const userData = {
-                    [this.config.auth.usernameField]: username,
-                    [this.config.auth.userFullNameField]: userFullName
-                };
-                const checkIsMenuItemVisible = (menuItem) => {
-                    if (typeof menuItem.visible === 'function') {
-                        const toReturn = menuItem.visible(adminUser);
-                        if (typeof toReturn !== 'boolean') {
-                            throw new Error(`'visible' function of ${menuItem.label || menuItem.type}  must return boolean value`);
-                        }
-                        return toReturn;
-                    }
-                };
-                let newMenu = [];
-                for (let menuItem of this.config.menu) {
-                    let newMenuItem = Object.assign({}, menuItem);
-                    if (menuItem.visible) {
-                        if (!checkIsMenuItemVisible(menuItem)) {
-                            continue;
-                        }
-                    }
-                    if (menuItem.children) {
-                        let newChildren = [];
-                        for (let child of menuItem.children) {
-                            let newChild = Object.assign({}, child);
-                            if (child.visible) {
-                                if (!checkIsMenuItemVisible(child)) {
-                                    continue;
-                                }
-                            }
-                            newChildren.push(newChild);
-                        }
-                        newMenuItem = Object.assign(Object.assign({}, newMenuItem), { children: newChildren });
-                    }
-                    newMenu.push(newMenuItem);
-                }
-                return {
-                    user: userData,
-                    resources: this.config.resources.map((res) => ({
-                        resourceId: res.resourceId,
-                        label: res.label,
-                    })),
-                    menu: newMenu,
-                    config: {
-                        brandName: this.config.customization.brandName,
-                        brandLogo: this.config.customization.brandLogo,
-                        datesFormat: this.config.customization.datesFormat,
-                        deleteConfirmation: this.config.deleteConfirmation,
-                        auth: this.config.auth,
-                        usernameField: this.config.auth.usernameField,
-                        title: (_m = this.config.customization) === null || _m === void 0 ? void 0 : _m.title,
-                        emptyFieldPlaceholder: (_o = this.config.customization) === null || _o === void 0 ? void 0 : _o.emptyFieldPlaceholder,
-                    },
-                    adminUser,
-                    version: ADMINFORTH_VERSION,
-                };
-            }),
-        });
-        function interpretResource(adminUser, resource, meta, source) {
-            return __awaiter(this, void 0, void 0, function* () {
-                var _b;
-                if (process.env.HEAVY_DEBUG) {
-                    console.log('🪲Interpreting resource', resource.resourceId, source);
-                }
-                const allowedActions = {};
-                yield Promise.all(Object.entries(((_b = resource.options) === null || _b === void 0 ? void 0 : _b.allowedActions) || {}).map((_c) => __awaiter(this, [_c], void 0, function* ([key, value]) {
-                    if (process.env.HEAVY_DEBUG) {
-                        console.log('🪲checking for allowed call', key, 'value:', value, 'typeof', typeof value);
-                    }
-                    // if callable then call
-                    if (typeof value === 'function') {
-                        allowedActions[key] = yield value({ adminUser, resource, meta, source });
-                    }
-                    else {
-                        allowedActions[key] = value;
-                    }
-                })));
-                return { allowedActions };
-            });
-        }
-        function checkAccess(action, allowedActions) {
-            const allowed = allowedActions[action];
-            if (allowed !== true) {
-                return { error: typeof allowed === 'string' ? allowed : 'Action is not allowed', allowed: false };
-            }
-            return { allowed: true };
-        }
-        server.endpoint({
-            method: 'POST',
-            path: '/get_resource',
-            handler: (_p) => __awaiter(this, [_p], void 0, function* ({ body, adminUser }) {
-                const { resourceId } = body;
-                if (!this.statuses.dbDiscover) {
-                    return { error: 'Database discovery not started' };
-                }
-                if (this.statuses.dbDiscover !== 'done') {
-                    return { error: 'Database discovery is still in progress, please try later' };
-                }
-                const resource = this.config.resources.find((res) => res.resourceId == resourceId);
-                if (!resource) {
-                    return { error: `Resource ${resourceId} not found` };
-                }
-                const { allowedActions } = yield interpretResource(adminUser, resource, {}, ActionCheckSource.DisplayButtons);
-                // exclude "plugins" key
-                return {
-                    resource: Object.assign(Object.assign({}, resource), { plugins: undefined, options: Object.assign(Object.assign({}, resource.options), { allowedActions }) })
-                };
-            }),
-        });
-        server.endpoint({
-            method: 'POST',
-            path: '/get_resource_data',
-            handler: (_q) => __awaiter(this, [_q], void 0, function* ({ body, adminUser }) {
-                var _r, _s, _t, _u;
-                const { resourceId, source } = body;
-                if (['show', 'list'].includes(source) === false) {
-                    return { error: 'Invalid source, should be list or show' };
-                }
-                if (!this.statuses.dbDiscover) {
-                    return { error: 'Database discovery not started' };
-                }
-                if (this.statuses.dbDiscover !== 'done') {
-                    return { error: 'Database discovery is still in progress, please try later' };
-                }
-                const resource = this.config.resources.find((res) => res.resourceId == resourceId);
-                if (!resource) {
-                    return { error: `Resource ${resourceId} not found` };
-                }
-                const { allowedActions } = yield interpretResource(adminUser, resource, { requestBody: body }, ActionCheckSource.DisplayButtons);
-                const { allowed, error } = checkAccess(source, allowedActions);
-                if (!allowed) {
-                    return { error };
-                }
-                for (const hook of listify((_s = (_r = resource.hooks) === null || _r === void 0 ? void 0 : _r[source]) === null || _s === void 0 ? void 0 : _s.beforeDatasourceRequest)) {
-                    const resp = yield hook({ resource, query: body, adminUser });
-                    if (!resp || (!resp.ok && !resp.error)) {
-                        throw new Error(`Hook must return object with {ok: true} or { error: 'Error' } `);
-                    }
-                    if (resp.error) {
-                        return { error: resp.error };
-                    }
-                }
-                const { limit, offset, filters, sort } = body;
-                for (const filter of (filters || [])) {
-                    if (!Object.values(AdminForthFilterOperators).includes(filter.operator)) {
-                        throw new Error(`Operator '${filter.operator}' is not allowed`);
-                    }
-                    if (!resource.columns.some((col) => col.name === filter.field)) {
-                        throw new Error(`Field '${filter.field}' is not in resource '${resource.resourceId}'. Available fields: ${resource.columns.map((col) => col.name).join(', ')}`);
-                    }
-                    if (filter.operator === AdminForthFilterOperators.IN || filter.operator === AdminForthFilterOperators.NIN) {
-                        if (!Array.isArray(filter.value)) {
-                            throw new Error(`Value for operator '${filter.operator}' should be an array`);
-                        }
-                    }
-                    if (filter.operator === AdminForthFilterOperators.IN && filter.value.length === 0) {
-                        // nonsense
-                        return { data: [], total: 0 };
-                    }
-                }
-                const data = yield this.connectors[resource.dataSource].getData({
-                    resource,
-                    limit,
-                    offset,
-                    filters,
-                    sort,
-                });
-                // for foreign keys, add references
-                yield Promise.all(resource.columns.filter((col) => col.foreignResource).map((col) => __awaiter(this, void 0, void 0, function* () {
-                    const targetResource = this.config.resources.find((res) => res.resourceId == col.foreignResource.resourceId);
-                    const targetConnector = this.connectors[targetResource.dataSource];
-                    const targetResourcePkField = targetResource.columns.find((col) => col.primaryKey).name;
-                    const pksUnique = [...new Set(data.data.map((item) => item[col.name]))];
-                    if (pksUnique.length === 0) {
-                        return;
-                    }
-                    const targetData = yield targetConnector.getData({
-                        resource: targetResource,
-                        limit: limit,
-                        offset: 0,
-                        filters: [
-                            {
-                                field: targetResourcePkField,
-                                operator: AdminForthFilterOperators.IN,
-                                value: pksUnique,
-                            }
-                        ],
-                        sort: [],
-                    });
-                    const targetDataMap = targetData.data.reduce((acc, item) => {
-                        acc[item[targetResourcePkField]] = {
-                            label: targetResource.recordLabel(item),
-                            pk: item[targetResourcePkField],
-                        };
-                        return acc;
-                    }, {});
-                    data.data.forEach((item) => {
-                        item[col.name] = targetDataMap[item[col.name]];
-                    });
-                })));
-                for (const hook of listify((_u = (_t = resource.hooks) === null || _t === void 0 ? void 0 : _t[source]) === null || _u === void 0 ? void 0 : _u.afterDatasourceResponse)) {
-                    const resp = yield hook({ resource, response: data.data, adminUser });
-                    if (!resp || (!resp.ok && !resp.error)) {
-                        throw new Error(`Hook must return object with {ok: true} or { error: 'Error' } `);
-                    }
-                    if (resp.error) {
-                        return { error: resp.error };
-                    }
-                }
-                // remove all columns which are not defined in resources, or defined but backendOnly
-                data.data.forEach((item) => {
-                    Object.keys(item).forEach((key) => {
-                        if (!resource.columns.find((col) => col.name === key) || resource.columns.find((col) => col.name === key && col.backendOnly)) {
-                            delete item[key];
-                        }
-                    });
-                });
-                data.data.forEach((item) => {
-                    item._label = resource.recordLabel(item);
-                });
-                return Object.assign(Object.assign({}, data), { options: resource === null || resource === void 0 ? void 0 : resource.options });
-            }),
-        });
-        server.endpoint({
-            method: 'POST',
-            path: '/get_resource_foreign_data',
-            handler: (_v) => __awaiter(this, [_v], void 0, function* ({ body, adminUser }) {
-                var _w, _x, _y, _z;
-                const { resourceId, column } = body;
-                if (!this.statuses.dbDiscover) {
-                    return { error: 'Database discovery not started' };
-                }
-                if (this.statuses.dbDiscover !== 'done') {
-                    return { error: 'Database discovery is still in progress, please try later' };
-                }
-                const resource = this.config.resources.find((res) => res.resourceId == resourceId);
-                if (!resource) {
-                    return { error: `Resource '${resourceId}' not found` };
-                }
-                const columnConfig = resource.columns.find((col) => col.name == column);
-                if (!columnConfig) {
-                    return { error: `Column "${column}' not found in resource with resourceId '${resourceId}'` };
-                }
-                if (!columnConfig.foreignResource) {
-                    return { error: `Column '${column}' in resource '${resourceId}' is not a foreign key` };
-                }
-                const targetResourceId = columnConfig.foreignResource.resourceId;
-                const targetResource = this.config.resources.find((res) => res.resourceId == targetResourceId);
-                for (const hook of listify((_x = (_w = columnConfig.foreignResource.hooks) === null || _w === void 0 ? void 0 : _w.dropdownList) === null || _x === void 0 ? void 0 : _x.beforeDatasourceRequest)) {
-                    const resp = yield hook({ query: body, adminUser, resource: targetResource });
-                    if (!resp || (!resp.ok && !resp.error)) {
-                        throw new Error(`Hook must return object with {ok: true} or { error: 'Error' } `);
-                    }
-                    if (resp.error) {
-                        return { error: resp.error };
-                    }
-                }
-                const { limit, offset, filters, sort } = body;
-                const dbDataItems = yield this.connectors[targetResource.dataSource].getData({
-                    resource: targetResource,
-                    limit,
-                    offset,
-                    filters: filters || [],
-                    sort: sort || [],
-                });
-                const items = dbDataItems.data.map((item) => {
-                    const pk = item[targetResource.columns.find((col) => col.primaryKey).name];
-                    const labler = targetResource.recordLabel;
-                    return {
-                        value: pk,
-                        label: labler(item),
-                        _item: item, // user might need it in hook to form new label
-                    };
-                });
-                const response = {
-                    items
-                };
-                for (const hook of listify((_z = (_y = columnConfig.foreignResource.hooks) === null || _y === void 0 ? void 0 : _y.dropdownList) === null || _z === void 0 ? void 0 : _z.afterDatasourceResponse)) {
-                    const resp = yield hook({ response, adminUser, resource: targetResource });
-                    if (!resp || (!resp.ok && !resp.error)) {
-                        throw new Error(`Hook must return object with {ok: true} or { error: 'Error' } `);
-                    }
-                    if (resp.error) {
-                        return { error: resp.error };
-                    }
-                }
-                return response;
-            }),
-        });
-        server.endpoint({
-            method: 'POST',
-            path: '/get_min_max_for_columns',
-            handler: (_0) => __awaiter(this, [_0], void 0, function* ({ body }) {
-                const { resourceId } = body;
-                if (!this.statuses.dbDiscover) {
-                    return { error: 'Database discovery not started' };
-                }
-                if (this.statuses.dbDiscover !== 'done') {
-                    return { error: 'Database discovery is still in progress, please try later' };
-                }
-                const resource = this.config.resources.find((res) => res.resourceId == resourceId);
-                if (!resource) {
-                    return { error: `Resource '${resourceId}' not found` };
-                }
-                const item = yield this.connectors[resource.dataSource].getMinMaxForColumns({
-                    resource,
-                    columns: resource.columns.filter((col) => [
-                        AdminForthDataTypes.INTEGER,
-                        AdminForthDataTypes.FLOAT,
-                        AdminForthDataTypes.DATE,
-                        AdminForthDataTypes.DATETIME,
-                        AdminForthDataTypes.TIME,
-                        AdminForthDataTypes.DECIMAL,
-                    ].includes(col.type) && col.allowMinMaxQuery === true),
-                });
-                return item;
-            }),
-        });
-        server.endpoint({
-            method: 'POST',
-            path: '/create_record',
-            handler: (_1) => __awaiter(this, [_1], void 0, function* ({ body, adminUser }) {
-                const resource = this.config.resources.find((res) => res.resourceId == body['resourceId']);
-                if (!resource) {
-                    return { error: `Resource '${body['resourceId']}' not found` };
-                }
-                const { allowedActions } = yield interpretResource(adminUser, resource, { requestBody: body }, ActionCheckSource.CreateRequest);
-                const { allowed, error } = checkAccess(AllowedActionsEnum.create, allowedActions);
-                if (!allowed) {
-                    return { error };
-                }
-                const { record } = body;
-                yield this.createResourceRecord({ resource, record, adminUser });
-                const connector = this.connectors[resource.dataSource];
-                return {
-                    newRecordId: body['record'][connector.getPrimaryKey(resource)]
-                };
-            })
-        });
-        server.endpoint({
-            method: 'POST',
-            path: '/update_record',
-            handler: (_2) => __awaiter(this, [_2], void 0, function* ({ body, adminUser }) {
-                var _3, _4, _5, _6;
-                const resource = this.config.resources.find((res) => res.resourceId == body['resourceId']);
-                if (!resource) {
-                    return { error: `Resource '${body['resourceId']}' not found` };
-                }
-                const recordId = body['recordId'];
-                const connector = this.connectors[resource.dataSource];
-                const oldRecord = yield connector.getRecordByPrimaryKey(resource, recordId);
-                if (!oldRecord) {
-                    const primaryKeyColumn = resource.columns.find((col) => col.primaryKey);
-                    return { error: `Record with ${primaryKeyColumn.name} ${recordId} not found` };
-                }
-                const record = body['record'];
-                const { allowedActions } = yield interpretResource(adminUser, resource, { requestBody: body, newRecord: record, oldRecord }, ActionCheckSource.EditRequest);
-                const { allowed, error } = checkAccess(AllowedActionsEnum.edit, allowedActions);
-                if (!allowed) {
-                    return { error };
-                }
-                // execute hook if needed
-                for (const hook of listify((_4 = (_3 = resource.hooks) === null || _3 === void 0 ? void 0 : _3.edit) === null || _4 === void 0 ? void 0 : _4.beforeSave)) {
-                    const resp = yield hook({ resource, record, adminUser });
-                    if (!resp || (!resp.ok && !resp.error)) {
-                        throw new Error(`Hook beforeSave must return object with {ok: true} or { error: 'Error' } `);
-                    }
-                    if (resp.error) {
-                        return { error: resp.error };
-                    }
-                }
-                const newValues = {};
-                for (const recordField in record) {
-                    if (record[recordField] !== oldRecord[recordField]) {
-                        const column = resource.columns.find((col) => col.name === recordField);
-                        if (column) {
-                            if (!column.virtual) {
-                                newValues[recordField] = connector.setFieldValue(column, record[recordField]);
-                            }
-                        }
-                        else {
-                            newValues[recordField] = record[recordField];
-                        }
-                    }
-                }
-                if (Object.keys(newValues).length > 0) {
-                    yield connector.updateRecord({ resource, recordId, newValues });
-                }
-                // execute hook if needed
-                for (const hook of listify((_6 = (_5 = resource.hooks) === null || _5 === void 0 ? void 0 : _5.edit) === null || _6 === void 0 ? void 0 : _6.afterSave)) {
-                    const resp = yield hook({ resource, record, adminUser, oldRecord });
-                    if (!resp || (!resp.ok && !resp.error)) {
-                        throw new Error(`Hook afterSave must return object with {ok: true} or { error: 'Error' } `);
-                    }
-                    if (resp.error) {
-                        return { error: resp.error };
-                    }
-                }
-                return {
-                    newRecordId: recordId
-                };
-            })
-        });
-        server.endpoint({
-            method: 'POST',
-            path: '/delete_record',
-            handler: (_7) => __awaiter(this, [_7], void 0, function* ({ body, adminUser }) {
-                var _8, _9, _10, _11;
-                const resource = this.config.resources.find((res) => res.resourceId == body['resourceId']);
-                const record = yield this.connectors[resource.dataSource].getRecordByPrimaryKey(resource, body['primaryKey']);
-                if (!resource) {
-                    return { error: `Resource '${body['resourceId']}' not found` };
-                }
-                if (!record) {
-                    return { error: `Record with ${body['primaryKey']} not found` };
-                }
-                if (resource.options.allowedActions.delete === false) {
-                    return { error: `Resource '${resource.resourceId}' does not allow delete action` };
-                }
-                const { allowedActions } = yield interpretResource(adminUser, resource, { requestBody: body }, ActionCheckSource.DeleteRequest);
-                const { allowed, error } = checkAccess(AllowedActionsEnum.delete, allowedActions);
-                if (!allowed) {
-                    return { error };
-                }
-                // execute hook if needed
-                for (const hook of listify((_9 = (_8 = resource.hooks) === null || _8 === void 0 ? void 0 : _8.delete) === null || _9 === void 0 ? void 0 : _9.beforeSave)) {
-                    const resp = yield hook({ resource, record, adminUser });
-                    if (!resp || (!resp.ok && !resp.error)) {
-                        throw new Error(`Hook beforeSave must return object with {ok: true} or { error: 'Error' } `);
-                    }
-                    if (resp.error) {
-                        return { error: resp.error };
-                    }
-                }
-                const connector = this.connectors[resource.dataSource];
-                yield connector.deleteRecord({ resource, recordId: body['primaryKey'] });
-                // execute hook if needed
-                for (const hook of listify((_11 = (_10 = resource.hooks) === null || _10 === void 0 ? void 0 : _10.delete) === null || _11 === void 0 ? void 0 : _11.afterSave)) {
-                    const resp = yield hook({ resource, record, adminUser });
-                    if (!resp || (!resp.ok && !resp.error)) {
-                        throw new Error(`Hook afterSave must return object with {ok: true} or { error: 'Error' } `);
-                    }
-                    if (resp.error) {
-                        return { error: resp.error };
-                    }
-                }
-                return {
-                    recordId: body['primaryKey']
-                };
-            })
-        });
-        server.endpoint({
-            method: 'POST',
-            path: '/start_bulk_action',
-            handler: (_12) => __awaiter(this, [_12], void 0, function* ({ body }) {
-                const { resourceId, actionId, recordIds } = body;
-                const resource = this.config.resources.find((res) => res.resourceId == resourceId);
-                if (!resource) {
-                    return { error: `Resource '${resourceId}' not found` };
-                }
-                const action = resource.options.bulkActions.find((act) => act.id == actionId);
-                if (!action) {
-                    return { error: `Action '${actionId}' not found` };
-                }
-                else {
-                    yield action.action({ selectedIds: recordIds });
-                }
-                return {
-                    actionId,
-                    recordIds,
-                    resourceId,
-                    status: 'success'
-                };
-            })
-        });
-        // setup endpoints for all plugins
-        this.activatedPlugins.forEach((plugin) => {
-            plugin.setupEndpoints(server);
-        });
+        this.restApi.registerEndpoints(server);
     }
 }
 _a = AdminForth, _AdminForth_defaultConfig = new WeakMap();