adminforth 1.1.91 → 1.1.93

package/plugins/TwoFactorsAuthPlugin/dist/index.js

@@ -0,0 +1,1186 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _a, _AdminForth_defaultConfig;
+import AdminForthAuth from './auth.js';
+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';
+//get array from enum AdminForthResourcePages
+class AdminForth {
+    constructor(config) {
+        _AdminForth_defaultConfig.set(this, {
+            deleteConfirmation: true,
+        });
+        this.config = Object.assign(Object.assign({}, __classPrivateFieldGet(this, _AdminForth_defaultConfig, "f")), config);
+        this.codeInjector = new CodeInjector(this);
+        this.activatedPlugins = [];
+        this.validateConfig();
+        this.activatePlugins();
+        this.validateConfig(); // revalidate after plugins
+        this.express = new ExpressServer(this);
+        this.auth = new AdminForthAuth(this);
+        this.connectors = {};
+        this.statuses = {};
+        console.log(`🚀 AdminForth v${ADMINFORTH_VERSION} starting up`);
+    }
+    activatePlugins() {
+        for (let resource of this.config.resources) {
+            for (let pluginInstance of resource.plugins || []) {
+                pluginInstance.modifyResourceConfig(this, resource);
+                this.activatedPlugins.push(pluginInstance);
+            }
+        }
+        ;
+    }
+    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 before going to 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.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);
+                }
+            });
+        }
+        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';
+            this.connectorClasses = {
+                'sqlite': SQLiteConnector,
+                'postgres': PostgresConnector,
+                'mongodb': MongoConnector,
+            };
+            if (!this.config.databaseConnectors) {
+                this.config.databaseConnectors = Object.assign({}, this.connectorClasses);
+            }
+            this.config.dataSources.forEach((ds) => {
+                const dbType = ds.url.split(':')[0];
+                if (!this.config.databaseConnectors[dbType]) {
+                    throw new Error(`Database type ${dbType} is not supported, consider using databaseConnectors in AdminForth config`);
+                }
+                this.connectors[ds.id] = new this.config.databaseConnectors[dbType]({ url: ds.url });
+            });
+            yield Promise.all(this.config.resources.map((res) => __awaiter(this, void 0, void 0, function* () {
+                if (!this.connectors[res.dataSource]) {
+                    throw new Error(`Resource '${res.table}' refers to unknown dataSource '${res.dataSource}'`);
+                }
+                const fieldTypes = yield this.connectors[res.dataSource].discoverFields(res);
+                if (!Object.keys(fieldTypes).length) {
+                    throw new Error(`Table '${res.table}' (In resource '${res.resourceId}') has no fields or does not exist`);
+                }
+                if (!res.columns) {
+                    res.columns = Object.keys(fieldTypes).map((name) => ({ name }));
+                }
+                res.columns.forEach((col, i) => {
+                    if (!fieldTypes[col.name] && !col.virtual) {
+                        throw new Error(`Resource '${res.table}' has no column '${col.name}'`);
+                    }
+                    // first find discovered values, but allow override
+                    res.columns[i] = Object.assign(Object.assign({}, fieldTypes[col.name]), col);
+                });
+                this.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`);
+                }
+            })));
+            this.statuses.dbDiscover = 'done';
+            // console.log('⚙️⚙️⚙️ Database discovery done', JSON.stringify(this.config.resources, null, 2));
+        });
+    }
+    bundleNow(_b) {
+        return __awaiter(this, arguments, void 0, function* ({ hotReload = false, verbose = false }) {
+            yield this.codeInjector.bundleNow({ hotReload, verbose });
+        });
+    }
+    getUserByPk(pk) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resource = this.config.resources.find((res) => res.resourceId === this.config.auth.resourceId);
+            if (!resource) {
+                throw new Error('No auth resource found');
+            }
+            const users = yield this.connectors[resource.dataSource].getData({
+                resource,
+                filters: [
+                    { field: resource.columns.find((col) => col.primaryKey).name, operator: AdminForthFilterOperators.EQ, value: pk },
+                ],
+                limit: 1,
+                offset: 0,
+                sort: [],
+            });
+            return users.data[0] || null;
+        });
+    }
+    createResourceRecord(_b) {
+        return __awaiter(this, arguments, void 0, function* ({ resource, record, adminUser }) {
+            var _c, _d, _e, _f, _g;
+            for (const column of resource.columns) {
+                if (column.fillOnCreate) {
+                    if (record[column.name] === undefined) {
+                        record[column.name] = column.fillOnCreate({
+                            initialRecord: record, adminUser
+                        });
+                    }
+                }
+                if (((_c = column.required) === null || _c === void 0 ? void 0 : _c.create) && record[column.name] === undefined) {
+                    return { error: `Column '${column.name}' is required` };
+                }
+                if (column.isUnique) {
+                    const existingRecord = yield this.connectors[resource.dataSource].getData({
+                        resource,
+                        filters: [{ field: column.name, operator: AdminForthFilterOperators.EQ, value: record[column.name] }],
+                        limit: 1,
+                        sort: [],
+                        offset: 0
+                    });
+                    if (existingRecord.data.length > 0) {
+                        return { error: `Record with ${column.name} ${record[column.name]} already exists` };
+                    }
+                }
+            }
+            // execute hook if needed
+            for (const hook of listify((_e = (_d = resource.hooks) === null || _d === void 0 ? void 0 : _d.create) === null || _e === void 0 ? void 0 : _e.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 };
+                }
+            }
+            // remove virtual columns from record
+            for (const column of resource.columns.filter((col) => col.virtual)) {
+                if (record[column.name]) {
+                    delete record[column.name];
+                }
+            }
+            const connector = this.connectors[resource.dataSource];
+            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)) {
+                console.log('Hook afterSave', hook);
+                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 };
+                }
+            }
+        });
+    }
+    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, _g, _h;
+                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({ userRecord: adminUser });
+                                if ((_d = resp === null || resp === void 0 ? void 0 : resp.body) === null || _d === void 0 ? void 0 : _d.setCookie) {
+                                    (_e = resp === null || resp === void 0 ? void 0 : resp.body) === null || _e === void 0 ? void 0 : _e.setCookie.forEach((cookie) => {
+                                        this.auth.setCustomCookie({ response, payload: cookie });
+                                    });
+                                }
+                                if ((_f = resp === null || resp === void 0 ? void 0 : resp.body) === null || _f === void 0 ? void 0 : _f.redirectTo) {
+                                    toReturn = { ok: resp.ok, redirectTo: (_g = resp === null || resp === void 0 ? void 0 : resp.body) === null || _g === void 0 ? void 0 : _g.redirectTo, allowedLogin: (_h = resp === null || resp === void 0 ? void 0 : resp.body) === null || _h === void 0 ? void 0 : _h.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: (_j) => __awaiter(this, [_j], void 0, function* ({ adminUser }) {
+                return { ok: true };
+            }),
+        });
+        server.endpoint({
+            noAuth: true,
+            method: 'POST',
+            path: '/logout',
+            handler: (_k) => __awaiter(this, [_k], void 0, function* ({ response }) {
+                this.auth.removeAuthCookie(response);
+                return { ok: true };
+            }),
+        });
+        server.endpoint({
+            noAuth: true,
+            method: 'GET',
+            path: '/get_public_config',
+            handler: (_l) => __awaiter(this, [_l], void 0, function* ({ body }) {
+                var _m;
+                // 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: (_m = this.config.customization) === null || _m === void 0 ? void 0 : _m.title,
+                };
+            }),
+        });
+        server.endpoint({
+            method: 'GET',
+            path: '/get_base_config',
+            handler: (_o) => __awaiter(this, [_o], void 0, function* ({ input, adminUser, cookies }) {
+                var _p, _q;
+                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: (_p = this.config.customization) === null || _p === void 0 ? void 0 : _p.title,
+                        emptyFieldPlaceholder: (_q = this.config.customization) === null || _q === void 0 ? void 0 : _q.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: (_r) => __awaiter(this, [_r], 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: (_s) => __awaiter(this, [_s], void 0, function* ({ body, adminUser }) {
+                var _t, _u, _v, _w;
+                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((_u = (_t = resource.hooks) === null || _t === void 0 ? void 0 : _t[source]) === null || _u === void 0 ? void 0 : _u.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((_w = (_v = resource.hooks) === null || _v === void 0 ? void 0 : _v[source]) === null || _w === void 0 ? void 0 : _w.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: (_x) => __awaiter(this, [_x], void 0, function* ({ body, adminUser }) {
+                var _y, _z, _0, _1;
+                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((_z = (_y = columnConfig.foreignResource.hooks) === null || _y === void 0 ? void 0 : _y.dropdownList) === null || _z === void 0 ? void 0 : _z.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((_1 = (_0 = columnConfig.foreignResource.hooks) === null || _0 === void 0 ? void 0 : _0.dropdownList) === null || _1 === void 0 ? void 0 : _1.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: (_2) => __awaiter(this, [_2], 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: (_3) => __awaiter(this, [_3], 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;
+                // call setFieldValue for each column
+                for (const column of resource.columns) {
+                    if (record[column.name] !== undefined) {
+                        record[column.name] = this.connectors[resource.dataSource].setFieldValue(column, record[column.name]);
+                    }
+                }
+                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: (_4) => __awaiter(this, [_4], void 0, function* ({ body, adminUser }) {
+                var _5, _6, _7, _8;
+                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((_6 = (_5 = resource.hooks) === null || _5 === void 0 ? void 0 : _5.edit) === null || _6 === void 0 ? void 0 : _6.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((_8 = (_7 = resource.hooks) === null || _7 === void 0 ? void 0 : _7.edit) === null || _8 === void 0 ? void 0 : _8.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: (_9) => __awaiter(this, [_9], void 0, function* ({ body, adminUser }) {
+                var _10, _11, _12, _13;
+                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((_11 = (_10 = resource.hooks) === null || _10 === void 0 ? void 0 : _10.delete) === null || _11 === void 0 ? void 0 : _11.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((_13 = (_12 = resource.hooks) === null || _12 === void 0 ? void 0 : _12.delete) === null || _13 === void 0 ? void 0 : _13.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: (_14) => __awaiter(this, [_14], 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);
+        });
+    }
+}
+_a = AdminForth, _AdminForth_defaultConfig = new WeakMap();
+AdminForth.Types = AdminForthDataTypes;
+AdminForth.Utils = {
+    generatePasswordHash: (password) => __awaiter(void 0, void 0, void 0, function* () {
+        return yield AdminForthAuth.generatePasswordHash(password);
+    })
+};
+export default AdminForth;