adminforth 1.2.1 → 1.2.2

package/dist/modules/restApi.js

@@ -0,0 +1,625 @@
+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());
+    });
+};
+import { AdminForthFilterOperators, AdminForthDataTypes, AllowedActionsEnum, ActionCheckSource } from "../types/AdminForthConfig.js";
+import { ADMINFORTH_VERSION, listify } from './utils.js';
+import AdminForthAuth from "../auth.js";
+export default class AdminForthRestAPI {
+    constructor(adminforth) {
+        this.adminforth = adminforth;
+    }
+    registerEndpoints(server) {
+        server.endpoint({
+            noAuth: true,
+            method: 'POST',
+            path: '/login',
+            handler: (_a) => __awaiter(this, [_a], void 0, function* ({ body, response }) {
+                var _b, _c, _d, _e;
+                const INVALID_MESSAGE = 'Invalid username or password';
+                const { username, password } = body;
+                let adminUser;
+                let toReturn = { ok: true, allowedLogin: true };
+                let token;
+                if (username === this.adminforth.config.rootUser.username && password === this.adminforth.config.rootUser.password) {
+                    this.adminforth.auth.setAuthCookie({ response, username, pk: null });
+                    adminUser = { isRoot: true, dbUser: null, pk: null, username: this.adminforth.config.rootUser.username };
+                }
+                else {
+                    // get resource from db
+                    if (!this.adminforth.config.auth) {
+                        throw new Error('No config.auth defined');
+                    }
+                    const userResource = this.adminforth.config.resources.find((res) => res.resourceId === this.adminforth.config.auth.resourceId);
+                    // if there is no passwordHashField, in columns, add it, with backendOnly and showIn: []
+                    if (!userResource.dataSourceColumns.find((col) => col.name === this.adminforth.config.auth.passwordHashField)) {
+                        userResource.dataSourceColumns.push({
+                            name: this.adminforth.config.auth.passwordHashField,
+                            backendOnly: true,
+                            showIn: [],
+                            type: AdminForthDataTypes.STRING,
+                        });
+                        console.log('Adding passwordHashField to userResource', userResource);
+                    }
+                    const userRecord = (_b = (yield this.adminforth.connectors[userResource.dataSource].getData({
+                        resource: userResource,
+                        filters: [
+                            { field: this.adminforth.config.auth.usernameField, operator: AdminForthFilterOperators.EQ, value: username },
+                        ],
+                        limit: 1,
+                        offset: 0,
+                        sort: [],
+                    })).data) === null || _b === void 0 ? void 0 : _b[0];
+                    if (!userRecord) {
+                        return { error: 'User not found' };
+                    }
+                    const passwordHash = userRecord[this.adminforth.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.adminforth.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 ((_c = resp === null || resp === void 0 ? void 0 : resp.body) === null || _c === void 0 ? void 0 : _c.redirectTo) {
+                                    toReturn = { ok: resp.ok, redirectTo: (_d = resp === null || resp === void 0 ? void 0 : resp.body) === null || _d === void 0 ? void 0 : _d.redirectTo, allowedLogin: (_e = resp === null || resp === void 0 ? void 0 : resp.body) === null || _e === void 0 ? void 0 : _e.allowedLogin };
+                                    break;
+                                }
+                            }
+                        }
+                        if (toReturn.allowedLogin) {
+                            this.adminforth.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: (_f) => __awaiter(this, [_f], void 0, function* ({ adminUser }) {
+                return { ok: true };
+            }),
+        });
+        server.endpoint({
+            noAuth: true,
+            method: 'POST',
+            path: '/logout',
+            handler: (_g) => __awaiter(this, [_g], void 0, function* ({ response }) {
+                this.adminforth.auth.removeAuthCookie(response);
+                return { ok: true };
+            }),
+        });
+        server.endpoint({
+            noAuth: true,
+            method: 'GET',
+            path: '/get_public_config',
+            handler: (_h) => __awaiter(this, [_h], void 0, function* ({ body }) {
+                var _j;
+                // find resource
+                if (!this.adminforth.config.auth) {
+                    throw new Error('No config.auth defined');
+                }
+                const usernameField = this.adminforth.config.auth.usernameField;
+                const resource = this.adminforth.config.resources.find((res) => res.resourceId === this.adminforth.config.auth.resourceId);
+                const usernameColumn = resource.columns.find((col) => col.name === usernameField);
+                return {
+                    brandName: this.adminforth.config.customization.brandName,
+                    usernameFieldName: usernameColumn.label,
+                    loginBackgroundImage: this.adminforth.config.auth.loginBackgroundImage,
+                    title: (_j = this.adminforth.config.customization) === null || _j === void 0 ? void 0 : _j.title,
+                };
+            }),
+        });
+        server.endpoint({
+            method: 'GET',
+            path: '/get_base_config',
+            handler: (_k) => __awaiter(this, [_k], void 0, function* ({ input, adminUser, cookies }) {
+                var _l, _m;
+                let username = '';
+                let userFullName = '';
+                if (adminUser.isRoot) {
+                    username = this.adminforth.config.rootUser.username;
+                }
+                else {
+                    const dbUser = adminUser.dbUser;
+                    username = dbUser[this.adminforth.config.auth.usernameField];
+                    userFullName = dbUser[this.adminforth.config.auth.userFullNameField];
+                }
+                const userData = {
+                    [this.adminforth.config.auth.usernameField]: username,
+                    [this.adminforth.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.adminforth.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.adminforth.config.resources.map((res) => ({
+                        resourceId: res.resourceId,
+                        label: res.label,
+                    })),
+                    menu: newMenu,
+                    config: {
+                        brandName: this.adminforth.config.customization.brandName,
+                        brandLogo: this.adminforth.config.customization.brandLogo,
+                        datesFormat: this.adminforth.config.customization.datesFormat,
+                        deleteConfirmation: this.adminforth.config.deleteConfirmation,
+                        auth: this.adminforth.config.auth,
+                        usernameField: this.adminforth.config.auth.usernameField,
+                        title: (_l = this.adminforth.config.customization) === null || _l === void 0 ? void 0 : _l.title,
+                        emptyFieldPlaceholder: (_m = this.adminforth.config.customization) === null || _m === void 0 ? void 0 : _m.emptyFieldPlaceholder,
+                    },
+                    adminUser,
+                    version: ADMINFORTH_VERSION,
+                };
+            }),
+        });
+        function interpretResource(adminUser, resource, meta, source) {
+            return __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                if (process.env.HEAVY_DEBUG) {
+                    console.log('🪲Interpreting resource', resource.resourceId, source);
+                }
+                const allowedActions = {};
+                yield Promise.all(Object.entries(((_a = resource.options) === null || _a === void 0 ? void 0 : _a.allowedActions) || {}).map((_b) => __awaiter(this, [_b], 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: (_o) => __awaiter(this, [_o], void 0, function* ({ body, adminUser }) {
+                const { resourceId } = body;
+                if (!this.adminforth.statuses.dbDiscover) {
+                    return { error: 'Database discovery not started' };
+                }
+                if (this.adminforth.statuses.dbDiscover !== 'done') {
+                    return { error: 'Database discovery is still in progress, please try later' };
+                }
+                const resource = this.adminforth.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: (_p) => __awaiter(this, [_p], void 0, function* ({ body, adminUser }) {
+                var _q, _r, _s, _t;
+                const { resourceId, source } = body;
+                if (['show', 'list'].includes(source) === false) {
+                    return { error: 'Invalid source, should be list or show' };
+                }
+                if (!this.adminforth.statuses.dbDiscover) {
+                    return { error: 'Database discovery not started' };
+                }
+                if (this.adminforth.statuses.dbDiscover !== 'done') {
+                    return { error: 'Database discovery is still in progress, please try later' };
+                }
+                const resource = this.adminforth.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((_r = (_q = resource.hooks) === null || _q === void 0 ? void 0 : _q[source]) === null || _r === void 0 ? void 0 : _r.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.adminforth.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.adminforth.config.resources.find((res) => res.resourceId == col.foreignResource.resourceId);
+                    const targetConnector = this.adminforth.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((_t = (_s = resource.hooks) === null || _s === void 0 ? void 0 : _s[source]) === null || _t === void 0 ? void 0 : _t.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: (_u) => __awaiter(this, [_u], void 0, function* ({ body, adminUser }) {
+                var _v, _w, _x, _y;
+                const { resourceId, column } = body;
+                if (!this.adminforth.statuses.dbDiscover) {
+                    return { error: 'Database discovery not started' };
+                }
+                if (this.adminforth.statuses.dbDiscover !== 'done') {
+                    return { error: 'Database discovery is still in progress, please try later' };
+                }
+                const resource = this.adminforth.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.adminforth.config.resources.find((res) => res.resourceId == targetResourceId);
+                for (const hook of listify((_w = (_v = columnConfig.foreignResource.hooks) === null || _v === void 0 ? void 0 : _v.dropdownList) === null || _w === void 0 ? void 0 : _w.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.adminforth.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((_y = (_x = columnConfig.foreignResource.hooks) === null || _x === void 0 ? void 0 : _x.dropdownList) === null || _y === void 0 ? void 0 : _y.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: (_z) => __awaiter(this, [_z], void 0, function* ({ body }) {
+                const { resourceId } = body;
+                if (!this.adminforth.statuses.dbDiscover) {
+                    return { error: 'Database discovery not started' };
+                }
+                if (this.adminforth.statuses.dbDiscover !== 'done') {
+                    return { error: 'Database discovery is still in progress, please try later' };
+                }
+                const resource = this.adminforth.config.resources.find((res) => res.resourceId == resourceId);
+                if (!resource) {
+                    return { error: `Resource '${resourceId}' not found` };
+                }
+                const item = yield this.adminforth.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: (_0) => __awaiter(this, [_0], void 0, function* ({ body, adminUser }) {
+                const resource = this.adminforth.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;
+                const response = yield this.adminforth.createResourceRecord({ resource, record, adminUser });
+                if (response.error) {
+                    return { error: response.error };
+                }
+                const connector = this.adminforth.connectors[resource.dataSource];
+                return {
+                    newRecordId: record[connector.getPrimaryKey(resource)]
+                };
+            })
+        });
+        server.endpoint({
+            method: 'POST',
+            path: '/update_record',
+            handler: (_1) => __awaiter(this, [_1], void 0, function* ({ body, adminUser }) {
+                var _2, _3, _4, _5;
+                const resource = this.adminforth.config.resources.find((res) => res.resourceId == body['resourceId']);
+                if (!resource) {
+                    return { error: `Resource '${body['resourceId']}' not found` };
+                }
+                const recordId = body['recordId'];
+                const connector = this.adminforth.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((_3 = (_2 = resource.hooks) === null || _2 === void 0 ? void 0 : _2.edit) === null || _3 === void 0 ? void 0 : _3.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((_5 = (_4 = resource.hooks) === null || _4 === void 0 ? void 0 : _4.edit) === null || _5 === void 0 ? void 0 : _5.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: (_6) => __awaiter(this, [_6], void 0, function* ({ body, adminUser }) {
+                var _7, _8, _9, _10;
+                const resource = this.adminforth.config.resources.find((res) => res.resourceId == body['resourceId']);
+                const record = yield this.adminforth.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((_8 = (_7 = resource.hooks) === null || _7 === void 0 ? void 0 : _7.delete) === null || _8 === void 0 ? void 0 : _8.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.adminforth.connectors[resource.dataSource];
+                yield connector.deleteRecord({ resource, recordId: body['primaryKey'] });
+                // execute hook if needed
+                for (const hook of listify((_10 = (_9 = resource.hooks) === null || _9 === void 0 ? void 0 : _9.delete) === null || _10 === void 0 ? void 0 : _10.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: (_11) => __awaiter(this, [_11], void 0, function* ({ body }) {
+                const { resourceId, actionId, recordIds } = body;
+                const resource = this.adminforth.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.adminforth.activatedPlugins.forEach((plugin) => {
+            plugin.setupEndpoints(server);
+        });
+    }
+}